answer
stringlengths 15
1.25M
|
|---|
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Evol.TMovie.Domain.Models.Entities;
using Evol.TMovie.Domain.QueryEntries.Parameters;
using Evol.Common;
using Evol.Domain.Data;
using Evol.Common.Data;
namespace Evol.TMovie.Domain.QueryEntries
{
public interface ISeatQueryEntry : IQueryEntry
{
Task<Seat> FindAsync(Guid id);
Task<List<Seat>> SelectAsync(SeatQueryParameter param);
Task<IPaged<Seat>> PagedAsync(SeatQueryParameter param, int pageIndex, int pageSize);
}
}
|
package br.eti.arthurgregorio.fulljeearch.domain.security;
/**
*
* @author Arthur
*/
public interface ApplicationRoles {
public final String USER = "Usuario";
public final String ADMINISTRATOR = "Administrador";
}
|
package com.almende.dialog.example.agent;
import java.io.Serializable;
import java.net.URLDecoder;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.logging.Logger;
import javax.ws.rs.Consumes;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.QueryParam;
import javax.ws.rs.core.Response;
import com.almende.dialog.Settings;
import com.almende.dialog.model.Answer;
import com.almende.dialog.model.Question;
import com.almende.util.ParallelInit;
import com.almende.util.twigmongo.QueryResultIterator;
import com.almende.util.twigmongo.<API key>;
import com.almende.util.twigmongo.<API key>.RootFindCommand;
import com.almende.util.twigmongo.annotations.Id;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ObjectNode;
@Path("yesno")
public class YesNoAgent {
static final ObjectMapper om =ParallelInit.getObjectMapper();
private static final String URL = "http://"+Settings.HOST+"/yesno/";
private static final String SOUNDURL = "http://ask4604.ask46.customers.luna.net/rest/";
private static final Logger log = Logger
.getLogger("DialogHandler");
public Question getQuestion(int question_no, String preferred_medium, String phonenumber) {
String questionURL = URL+"questions/"+question_no;
String answerYesURL = URL+"answers/0";
String answerNoURL = URL+"answers/1";
if (preferred_medium != null && preferred_medium.startsWith("audio")){
questionURL = this.getAudioFile(question_no);
answerYesURL= SOUNDURL+"14.wav";
answerNoURL= SOUNDURL+"14.wav";
}
Question question=new Question();
question.setRequester(URL+"id/");
question.setType("closed");
question.setQuestion_text(questionURL);
question.setAnswers(new ArrayList<Answer>(Arrays.asList(
new Answer(answerYesURL, URL+"questions/"+question_no+"?preferred_medium="+preferred_medium+"&pn="+phonenumber+"&answer=yes"),
new Answer(answerNoURL, URL+"questions/"+question_no+"?preferred_medium="+preferred_medium+"&pn="+phonenumber+"&answer=no"))));
return question;
}
@GET
@Path("/id/")
public Response getId(@QueryParam("preferred_language") String preferred_language){
ObjectNode node= om.createObjectNode();
node.put("url", URL);
node.put("nickname", "YesNo");
return Response.ok(node.toString()).build();
}
@GET
@Produces("application/json")
public Response firstQuestion(@QueryParam("preferred_medium") String preferred_medium, @QueryParam("remoteAddress") String responder, @QueryParam("requester") String requester){
int questionNo=0;
if(requester.contains("live") || requester.contains("0107421217")){
questionNo=1;
}
try {
responder = URLDecoder.decode(responder, "UTF-8");
} catch (Exception ex) {
log.severe(ex.getMessage());
}
Question question = getQuestion(questionNo, preferred_medium, responder);
return Response.ok(question.toJSON()).build();
}
@Path("/questions/{question_no}")
@POST
@Produces("application/json")
@Consumes("*/*")
public Response answerQuestion(@PathParam("question_no") String question_no, @QueryParam("preferred_medium") String preferred_medium,
@QueryParam("pn") String phonenumber, @QueryParam("answer") String answer){
Group group = this.getGroup("Group."+question_no+"."+answer);
group.addMember(phonenumber);
<API key> datastore = new <API key>();
datastore.store(group);
int responseQuestion=99;
String questionURL = URL+"questions/"+responseQuestion;
if (preferred_medium != null && preferred_medium.startsWith("audio")){
questionURL = this.getAudioFile(responseQuestion);
}
Question question=new Question();
question.setRequester(URL+"id/");
question.setType("comment");
question.setQuestion_text(questionURL);
return Response.ok( question.toJSON() ).build();
}
@Path("/questions/{question_no}")
@GET
@Produces("text/plain")
@Consumes("*/*")
public Response getQuestionText(@PathParam("question_no") String question_no ){
Integer questionNo = Integer.parseInt(question_no);
String result = "";
// These messages are now static but should be loaded from the LifeRay Database.
switch (questionNo){
case 0: result="Press 1 if you are available, press 2 if you are unavailable."; break;
case 1: result="Are you available?"; break;
case 99: result="Thank you for your input"; break;
default: result="Sorry, for some strange reason I don't have that question text available...";
}
return Response.ok(result).build();
}
@Path("/answers/{answer_no}")
@GET
@Produces("text/plain")
@Consumes("*/*")
public Response getAnswerText(@PathParam("answer_no") String answer_no, @QueryParam("preferred_medium") String prefered_mimeType){
Integer answerNo = Integer.parseInt(answer_no);
String result="";
// These messages can be static, because they are always the same.
switch (answerNo){
case 0: result="Yes"; break;
case 1: result="No"; break;
default: result="Sorry, for some strange reason I don't have that answer text available...";
}
return Response.ok(result).build();
}
// This urls will present the results
@Path("result")
@GET
public Response getResults() {
String result="";
ArrayList<Group> groups = (ArrayList<Group>) this.getAllGroups();
try {
result = om.writeValueAsString(groups);
} catch(Exception ex) {
ex.printStackTrace();
}
return Response.ok( result ).build();
}
// These functions should get there data from the liferay database.
// These are the audio files linked to the questions
public String getAudioFile(int question_no) {
switch(question_no) {
case 0: return SOUNDURL+"571.wav";
case 1: return SOUNDURL+"572.wav";
case 99: return SOUNDURL+"567.wav";
default: return SOUNDURL+"529.wav";
}
}
// These 2 functions are the group management
public Group getGroup(String id) {
<API key> datastore = new <API key>();
Group group = datastore.load(Group.class, id);
if(group!=null)
return group;
group = new Group();
group.setId(id);
return group;
}
public List<Group> getAllGroups() {
<API key> datastore = new <API key>();
RootFindCommand<Group> command = datastore.find()
.type(Group.class);
QueryResultIterator<Group> it = command.now();
List<Group> groups = new ArrayList<Group>();
while (it.hasNext()) {
groups.add(it.next());
}
return groups;
}
}
@SuppressWarnings("serial")
class Group implements Serializable {
public Group() {
this.members=new HashSet<String>();
}
public String getId(){
return id;
}
public void setId(String id){
this.id=id;
}
public Set<String> getMembers() {
return this.members;
}
public void addMember(String member) {
this.members.add(member);
}
@Id private String id=null;
private Set<String> members=null;
}
|
CREATE TABLE IF NOT EXISTS `uctoo_district` (
`id` mediumint(8) unsigned NOT NULL AUTO_INCREMENT,
`name` varchar(255) NOT NULL DEFAULT '',
`level` tinyint(4) unsigned NOT NULL DEFAULT '0',
`upid` mediumint(8) unsigned NOT NULL DEFAULT '0',
PRIMARY KEY (`id`)
) ENGINE=MyISAM DEFAULT CHARSET=utf8 COMMENT='';
INSERT INTO `uctoo_district` (`id`, `name`, `level`, `upid`) VALUES
(110000, '', 1, 0),
(120000, '', 1, 0),
(130000, '', 1, 0),
(140000, '', 1, 0),
(150000, '', 1, 0),
(210000, '', 1, 0),
(220000, '', 1, 0),
(230000, '', 1, 0),
(310000, '', 1, 0),
(320000, '', 1, 0),
(330000, '', 1, 0),
(340000, '', 1, 0),
(350000, '', 1, 0),
(360000, '', 1, 0),
(370000, '', 1, 0),
(410000, '', 1, 0),
(420000, '', 1, 0),
(430000, '', 1, 0),
(440000, '', 1, 0),
(450000, '', 1, 0),
(460000, '', 1, 0),
(500000, '', 1, 0),
(510000, '', 1, 0),
(520000, '', 1, 0),
(530000, '', 1, 0),
(540000, '', 1, 0),
(610000, '', 1, 0),
(620000, '', 1, 0),
(630000, '', 1, 0),
(640000, '', 1, 0),
(650000, '', 1, 0),
(710000, '', 1, 0),
(810000, '', 1, 0),
(820000, '', 1, 0),
(110100, '', 2, 110000),
(110200, '', 2, 110000),
(120100, '', 2, 120000),
(120200, '', 2, 120000),
(130100, '', 2, 130000),
(130200, '', 2, 130000),
(130300, '', 2, 130000),
(130400, '', 2, 130000),
(130500, '', 2, 130000),
(130600, '', 2, 130000),
(130700, '', 2, 130000),
(130800, '', 2, 130000),
(130900, '', 2, 130000),
(131000, '', 2, 130000),
(131100, '', 2, 130000),
(140100, '', 2, 140000),
(140200, '', 2, 140000),
(140300, '', 2, 140000),
(140400, '', 2, 140000),
(140500, '', 2, 140000),
(140600, '', 2, 140000),
(140700, '', 2, 140000),
(140800, '', 2, 140000),
(140900, '', 2, 140000),
(141000, '', 2, 140000),
(141100, '', 2, 140000),
(150100, '', 2, 150000),
(150200, '', 2, 150000),
(150300, '', 2, 150000),
(150400, '', 2, 150000),
(150500, '', 2, 150000),
(150600, '', 2, 150000),
(150700, '', 2, 150000),
(150800, '', 2, 150000),
(150900, '', 2, 150000),
(152200, '', 2, 150000),
(152500, '', 2, 150000),
(152900, '', 2, 150000),
(210100, '', 2, 210000),
(210200, '', 2, 210000),
(210300, '', 2, 210000),
(210400, '', 2, 210000),
(210500, '', 2, 210000),
(210600, '', 2, 210000),
(210700, '', 2, 210000),
(210800, '', 2, 210000),
(210900, '', 2, 210000),
(211000, '', 2, 210000),
(211100, '', 2, 210000),
(211200, '', 2, 210000),
(211300, '', 2, 210000),
(211400, '', 2, 210000),
(220100, '', 2, 220000),
(220200, '', 2, 220000),
(220300, '', 2, 220000),
(220400, '', 2, 220000),
(220500, '', 2, 220000),
(220600, '', 2, 220000),
(220700, '', 2, 220000),
(220800, '', 2, 220000),
(222400, '', 2, 220000),
(230100, '', 2, 230000),
(230200, '', 2, 230000),
(230300, '', 2, 230000),
(230400, '', 2, 230000),
(230500, '', 2, 230000),
(230600, '', 2, 230000),
(230700, '', 2, 230000),
(230800, '', 2, 230000),
(230900, '', 2, 230000),
(231000, '', 2, 230000),
(231100, '', 2, 230000),
(231200, '', 2, 230000),
(232700, '', 2, 230000),
(310100, '', 2, 310000),
(310200, '', 2, 310000),
(320100, '', 2, 320000),
(320200, '', 2, 320000),
(320300, '', 2, 320000),
(320400, '', 2, 320000),
(320500, '', 2, 320000),
(320600, '', 2, 320000),
(320700, '', 2, 320000),
(320800, '', 2, 320000),
(320900, '', 2, 320000),
(321000, '', 2, 320000),
(321100, '', 2, 320000),
(321200, '', 2, 320000),
(321300, '', 2, 320000),
(330100, '', 2, 330000),
(330200, '', 2, 330000),
(330300, '', 2, 330000),
(330400, '', 2, 330000),
(330500, '', 2, 330000),
(330600, '', 2, 330000),
(330700, '', 2, 330000),
(330800, '', 2, 330000),
(330900, '', 2, 330000),
(331000, '', 2, 330000),
(331100, '', 2, 330000),
(340100, '', 2, 340000),
(340200, '', 2, 340000),
(340300, '', 2, 340000),
(340400, '', 2, 340000),
(340500, '', 2, 340000),
(340600, '', 2, 340000),
(340700, '', 2, 340000),
(340800, '', 2, 340000),
(341000, '', 2, 340000),
(341100, '', 2, 340000),
(341200, '', 2, 340000),
(341300, '', 2, 340000),
(341500, '', 2, 340000),
(341600, '', 2, 340000),
(341700, '', 2, 340000),
(341800, '', 2, 340000),
(350100, '', 2, 350000),
(350200, '', 2, 350000),
(350300, '', 2, 350000),
(350400, '', 2, 350000),
(350500, '', 2, 350000),
(350600, '', 2, 350000),
(350700, '', 2, 350000),
(350800, '', 2, 350000),
(350900, '', 2, 350000),
(360100, '', 2, 360000),
(360200, '', 2, 360000),
(360300, '', 2, 360000),
(360400, '', 2, 360000),
(360500, '', 2, 360000),
(360600, '', 2, 360000),
(360700, '', 2, 360000),
(360800, '', 2, 360000),
(360900, '', 2, 360000),
(361000, '', 2, 360000),
(361100, '', 2, 360000),
(370100, '', 2, 370000),
(370200, '', 2, 370000),
(370300, '', 2, 370000),
(370400, '', 2, 370000),
(370500, '', 2, 370000),
(370600, '', 2, 370000),
(370700, '', 2, 370000),
(370800, '', 2, 370000),
(370900, '', 2, 370000),
(371000, '', 2, 370000),
(371100, '', 2, 370000),
(371200, '', 2, 370000),
(371300, '', 2, 370000),
(371400, '', 2, 370000),
(371500, '', 2, 370000),
(371600, '', 2, 370000),
(371700, '', 2, 370000),
(410100, '', 2, 410000),
(410200, '', 2, 410000),
(410300, '', 2, 410000),
(410400, '', 2, 410000),
(410500, '', 2, 410000),
(410600, '', 2, 410000),
(410700, '', 2, 410000),
(410800, '', 2, 410000),
(410900, '', 2, 410000),
(411000, '', 2, 410000),
(411100, '', 2, 410000),
(411200, '', 2, 410000),
(411300, '', 2, 410000),
(411400, '', 2, 410000),
(411500, '', 2, 410000),
(411600, '', 2, 410000),
(411700, '', 2, 410000),
(420100, '', 2, 420000),
(420200, '', 2, 420000),
(420300, '', 2, 420000),
(420500, '', 2, 420000),
(420600, '', 2, 420000),
(420700, '', 2, 420000),
(420800, '', 2, 420000),
(420900, '', 2, 420000),
(421000, '', 2, 420000),
(421100, '', 2, 420000),
(421200, '', 2, 420000),
(421300, '', 2, 420000),
(422800, '', 2, 420000),
(429000, '', 2, 420000),
(430100, '', 2, 430000),
(430200, '', 2, 430000),
(430300, '', 2, 430000),
(430400, '', 2, 430000),
(430500, '', 2, 430000),
(430600, '', 2, 430000),
(430700, '', 2, 430000),
(430800, '', 2, 430000),
(430900, '', 2, 430000),
(431000, '', 2, 430000),
(431100, '', 2, 430000),
(431200, '', 2, 430000),
(431300, '', 2, 430000),
(433100, '', 2, 430000),
(440100, '', 2, 440000),
(440200, '', 2, 440000),
(440300, '', 2, 440000),
(440400, '', 2, 440000),
(440500, '', 2, 440000),
(440600, '', 2, 440000),
(440700, '', 2, 440000),
(440800, '', 2, 440000),
(440900, '', 2, 440000),
(441200, '', 2, 440000),
(441300, '', 2, 440000),
(441400, '', 2, 440000),
(441500, '', 2, 440000),
(441600, '', 2, 440000),
(441700, '', 2, 440000),
(441800, '', 2, 440000),
(441900, '', 2, 440000),
(442000, '', 2, 440000),
(445100, '', 2, 440000),
(445200, '', 2, 440000),
(445300, '', 2, 440000),
(450100, '', 2, 450000),
(450200, '', 2, 450000),
(450300, '', 2, 450000),
(450400, '', 2, 450000),
(450500, '', 2, 450000),
(450600, '', 2, 450000),
(450700, '', 2, 450000),
(450800, '', 2, 450000),
(450900, '', 2, 450000),
(451000, '', 2, 450000),
(451100, '', 2, 450000),
(451200, '', 2, 450000),
(451300, '', 2, 450000),
(451400, '', 2, 450000),
(460100, '', 2, 460000),
(460200, '', 2, 460000),
(469000, '', 2, 460000),
(500100, '', 2, 500000),
(500200, '', 2, 500000),
(500300, '', 2, 500000),
(510100, '', 2, 510000),
(510300, '', 2, 510000),
(510400, '', 2, 510000),
(510500, '', 2, 510000),
(510600, '', 2, 510000),
(510700, '', 2, 510000),
(510800, '', 2, 510000),
(510900, '', 2, 510000),
(511000, '', 2, 510000),
(511100, '', 2, 510000),
(511300, '', 2, 510000),
(511400, '', 2, 510000),
(511500, '', 2, 510000),
(511600, '', 2, 510000),
(511700, '', 2, 510000),
(511800, '', 2, 510000),
(511900, '', 2, 510000),
(512000, '', 2, 510000),
(513200, '', 2, 510000),
(513300, '', 2, 510000),
(513400, '', 2, 510000),
(520100, '', 2, 520000),
(520200, '', 2, 520000),
(520300, '', 2, 520000),
(520400, '', 2, 520000),
(522200, '', 2, 520000),
(522300, '', 2, 520000),
(522400, '', 2, 520000),
(522600, '', 2, 520000),
(522700, '', 2, 520000),
(530100, '', 2, 530000),
(530300, '', 2, 530000),
(530400, '', 2, 530000),
(530500, '', 2, 530000),
(530600, '', 2, 530000),
(530700, '', 2, 530000),
(530800, '', 2, 530000),
(530900, '', 2, 530000),
(532300, '', 2, 530000),
(532500, '', 2, 530000),
(532600, '', 2, 530000),
(532800, '', 2, 530000),
(532900, '', 2, 530000),
(533100, '', 2, 530000),
(533300, '', 2, 530000),
(533400, '', 2, 530000),
(540100, '', 2, 540000),
(542100, '', 2, 540000),
(542200, '', 2, 540000),
(542300, '', 2, 540000),
(542400, '', 2, 540000),
(542500, '', 2, 540000),
(542600, '', 2, 540000),
(610100, '', 2, 610000),
(610200, '', 2, 610000),
(610300, '', 2, 610000),
(610400, '', 2, 610000),
(610500, '', 2, 610000),
(610600, '', 2, 610000),
(610700, '', 2, 610000),
(610800, '', 2, 610000),
(610900, '', 2, 610000),
(611000, '', 2, 610000),
(620100, '', 2, 620000),
(620200, '', 2, 620000),
(620300, '', 2, 620000),
(620400, '', 2, 620000),
(620500, '', 2, 620000),
(620600, '', 2, 620000),
(620700, '', 2, 620000),
(620800, '', 2, 620000),
(620900, '', 2, 620000),
(621000, '', 2, 620000),
(621100, '', 2, 620000),
(621200, '', 2, 620000),
(622900, '', 2, 620000),
(623000, '', 2, 620000),
(630100, '', 2, 630000),
(632100, '', 2, 630000),
(632200, '', 2, 630000),
(632300, '', 2, 630000),
(632500, '', 2, 630000),
(632600, '', 2, 630000),
(632700, '', 2, 630000),
(632800, '', 2, 630000),
(640100, '', 2, 640000),
(640200, '', 2, 640000),
(640300, '', 2, 640000),
(640400, '', 2, 640000),
(640500, '', 2, 640000),
(650100, '', 2, 650000),
(650200, '', 2, 650000),
(652100, '', 2, 650000),
(652200, '', 2, 650000),
(652300, '', 2, 650000),
(652700, '', 2, 650000),
(652800, '', 2, 650000),
(652900, '', 2, 650000),
(653000, '', 2, 650000),
(653100, '', 2, 650000),
(653200, '', 2, 650000),
(654000, '', 2, 650000),
(654200, '', 2, 650000),
(654300, '', 2, 650000),
(659000, '', 2, 650000),
(110101, '', 3, 110100),
(110102, '', 3, 110100),
(110103, '', 3, 110100),
(110104, '', 3, 110100),
(110105, '', 3, 110100),
(110106, '', 3, 110100),
(110107, '', 3, 110100),
(110108, '', 3, 110100),
(110109, '', 3, 110100),
(110111, '', 3, 110100),
(110112, '', 3, 110100),
(110113, '', 3, 110100),
(110114, '', 3, 110100),
(110115, '', 3, 110100),
(110116, '', 3, 110100),
(110117, '', 3, 110100),
(110228, '', 3, 110200),
(110229, '', 3, 110200),
(120101, '', 3, 120100),
(120102, '', 3, 120100),
(120103, '', 3, 120100),
(120104, '', 3, 120100),
(120105, '', 3, 120100),
(120106, '', 3, 120100),
(120107, '', 3, 120100),
(120108, '', 3, 120100),
(120109, '', 3, 120100),
(120110, '', 3, 120100),
(120111, '', 3, 120100),
(120112, '', 3, 120100),
(120113, '', 3, 120100),
(120114, '', 3, 120100),
(120115, '', 3, 120100),
(120221, '', 3, 120200),
(120223, '', 3, 120200),
(120225, '', 3, 120200),
(130101, '', 3, 130100),
(130102, '', 3, 130100),
(130103, '', 3, 130100),
(130104, '', 3, 130100),
(130105, '', 3, 130100),
(130107, '', 3, 130100),
(130108, '', 3, 130100),
(130121, '', 3, 130100),
(130123, '', 3, 130100),
(130124, '', 3, 130100),
(130125, '', 3, 130100),
(130126, '', 3, 130100),
(130127, '', 3, 130100),
(130128, '', 3, 130100),
(130129, '', 3, 130100),
(130130, '', 3, 130100),
(130131, '', 3, 130100),
(130132, '', 3, 130100),
(130133, '', 3, 130100),
(130181, '', 3, 130100),
(130182, '', 3, 130100),
(130183, '', 3, 130100),
(130184, '', 3, 130100),
(130185, '', 3, 130100),
(130201, '', 3, 130200),
(130202, '', 3, 130200),
(130203, '', 3, 130200),
(130204, '', 3, 130200),
(130205, '', 3, 130200),
(130207, '', 3, 130200),
(130208, '', 3, 130200),
(130223, '', 3, 130200),
(130224, '', 3, 130200),
(130225, '', 3, 130200),
(130227, '', 3, 130200),
(130229, '', 3, 130200),
(130230, '', 3, 130200),
(130281, '', 3, 130200),
(130283, '', 3, 130200),
(130301, '', 3, 130300),
(130302, '', 3, 130300),
(130303, '', 3, 130300),
(130304, '', 3, 130300),
(130321, '', 3, 130300),
(130322, '', 3, 130300),
(130323, '', 3, 130300),
(130324, '', 3, 130300),
(130401, '', 3, 130400),
(130402, '', 3, 130400),
(130403, '', 3, 130400),
(130404, '', 3, 130400),
(130406, '', 3, 130400),
(130421, '', 3, 130400),
(130423, '', 3, 130400),
(130424, '', 3, 130400),
(130425, '', 3, 130400),
(130426, '', 3, 130400),
(130427, '', 3, 130400),
(130428, '', 3, 130400),
(130429, '', 3, 130400),
(130430, '', 3, 130400),
(130431, '', 3, 130400),
(130432, '', 3, 130400),
(130433, '', 3, 130400),
(130434, '', 3, 130400),
(130435, '', 3, 130400),
(130481, '', 3, 130400),
(130501, '', 3, 130500),
(130502, '', 3, 130500),
(130503, '', 3, 130500),
(130521, '', 3, 130500),
(130522, '', 3, 130500),
(130523, '', 3, 130500),
(130524, '', 3, 130500),
(130525, '', 3, 130500),
(130526, '', 3, 130500),
(130527, '', 3, 130500),
(130528, '', 3, 130500),
(130529, '', 3, 130500),
(130530, '', 3, 130500),
(130531, '', 3, 130500),
(130532, '', 3, 130500),
(130533, '', 3, 130500),
(130534, '', 3, 130500),
(130535, '', 3, 130500),
(130581, '', 3, 130500),
(130582, '', 3, 130500),
(130601, '', 3, 130600),
(130602, '', 3, 130600),
(130603, '', 3, 130600),
(130604, '', 3, 130600),
(130621, '', 3, 130600),
(130622, '', 3, 130600),
(130623, '', 3, 130600),
(130624, '', 3, 130600),
(130625, '', 3, 130600),
(130626, '', 3, 130600),
(130627, '', 3, 130600),
(130628, '', 3, 130600),
(130629, '', 3, 130600),
(130630, '', 3, 130600),
(130631, '', 3, 130600),
(130632, '', 3, 130600),
(130633, '', 3, 130600),
(130634, '', 3, 130600),
(130635, '', 3, 130600),
(130636, '', 3, 130600),
(130637, '', 3, 130600),
(130638, '', 3, 130600),
(130681, '', 3, 130600),
(130682, '', 3, 130600),
(130683, '', 3, 130600),
(130684, '', 3, 130600),
(130701, '', 3, 130700),
(130702, '', 3, 130700),
(130703, '', 3, 130700),
(130705, '', 3, 130700),
(130706, '', 3, 130700),
(130721, '', 3, 130700),
(130722, '', 3, 130700),
(130723, '', 3, 130700),
(130724, '', 3, 130700),
(130725, '', 3, 130700),
(130726, '', 3, 130700),
(130727, '', 3, 130700),
(130728, '', 3, 130700),
(130729, '', 3, 130700),
(130730, '', 3, 130700),
(130731, '', 3, 130700),
(130732, '', 3, 130700),
(130733, '', 3, 130700),
(130801, '', 3, 130800),
(130802, '', 3, 130800),
(130803, '', 3, 130800),
(130804, '', 3, 130800),
(130821, '', 3, 130800),
(130822, '', 3, 130800),
(130823, '', 3, 130800),
(130824, '', 3, 130800),
(130825, '', 3, 130800),
(130826, '', 3, 130800),
(130827, '', 3, 130800),
(130828, '', 3, 130800),
(130901, '', 3, 130900),
(130902, '', 3, 130900),
(130903, '', 3, 130900),
(130921, '', 3, 130900),
(130922, '', 3, 130900),
(130923, '', 3, 130900),
(130924, '', 3, 130900),
(130925, '', 3, 130900),
(130926, '', 3, 130900),
(130927, '', 3, 130900),
(130928, '', 3, 130900),
(130929, '', 3, 130900),
(130930, '', 3, 130900),
(130981, '', 3, 130900),
(130982, '', 3, 130900),
(130983, '', 3, 130900),
(130984, '', 3, 130900),
(131001, '', 3, 131000),
(131002, '', 3, 131000),
(131003, '', 3, 131000),
(131022, '', 3, 131000),
(131023, '', 3, 131000),
(131024, '', 3, 131000),
(131025, '', 3, 131000),
(131026, '', 3, 131000),
(131028, '', 3, 131000),
(131081, '', 3, 131000),
(131082, '', 3, 131000),
(131101, '', 3, 131100),
(131102, '', 3, 131100),
(131121, '', 3, 131100),
(131122, '', 3, 131100),
(131123, '', 3, 131100),
(131124, '', 3, 131100),
(131125, '', 3, 131100),
(131126, '', 3, 131100),
(131127, '', 3, 131100),
(131128, '', 3, 131100),
(131181, '', 3, 131100),
(131182, '', 3, 131100),
(140101, '', 3, 140100),
(140105, '', 3, 140100),
(140106, '', 3, 140100),
(140107, '', 3, 140100),
(140108, '', 3, 140100),
(140109, '', 3, 140100),
(140110, '', 3, 140100),
(140121, '', 3, 140100),
(140122, '', 3, 140100),
(140123, '', 3, 140100),
(140181, '', 3, 140100),
(140201, '', 3, 140200),
(140202, '', 3, 140200),
(140203, '', 3, 140200),
(140211, '', 3, 140200),
(140212, '', 3, 140200),
(140221, '', 3, 140200),
(140222, '', 3, 140200),
(140223, '', 3, 140200),
(140224, '', 3, 140200),
(140225, '', 3, 140200),
(140226, '', 3, 140200),
(140227, '', 3, 140200),
(140301, '', 3, 140300),
(140302, '', 3, 140300),
(140303, '', 3, 140300),
(140311, '', 3, 140300),
(140321, '', 3, 140300),
(140322, '', 3, 140300),
(140401, '', 3, 140400),
(140402, '', 3, 140400),
(140411, '', 3, 140400),
(140421, '', 3, 140400),
(140423, '', 3, 140400),
(140424, '', 3, 140400),
(140425, '', 3, 140400),
(140426, '', 3, 140400),
(140427, '', 3, 140400),
(140428, '', 3, 140400),
(140429, '', 3, 140400),
(140430, '', 3, 140400),
(140431, '', 3, 140400),
(140481, '', 3, 140400),
(140501, '', 3, 140500),
(140502, '', 3, 140500),
(140521, '', 3, 140500),
(140522, '', 3, 140500),
(140524, '', 3, 140500),
(140525, '', 3, 140500),
(140581, '', 3, 140500),
(140601, '', 3, 140600),
(140602, '', 3, 140600),
(140603, '', 3, 140600),
(140621, '', 3, 140600),
(140622, '', 3, 140600),
(140623, '', 3, 140600),
(140624, '', 3, 140600),
(140701, '', 3, 140700),
(140702, '', 3, 140700),
(140721, '', 3, 140700),
(140722, '', 3, 140700),
(140723, '', 3, 140700),
(140724, '', 3, 140700),
(140725, '', 3, 140700),
(140726, '', 3, 140700),
(140727, '', 3, 140700),
(140728, '', 3, 140700),
(140729, '', 3, 140700),
(140781, '', 3, 140700),
(140801, '', 3, 140800),
(140802, '', 3, 140800),
(140821, '', 3, 140800),
(140822, '', 3, 140800),
(140823, '', 3, 140800),
(140824, '', 3, 140800),
(140825, '', 3, 140800),
(140826, '', 3, 140800),
(140827, '', 3, 140800),
(140828, '', 3, 140800),
(140829, '', 3, 140800),
(140830, '', 3, 140800),
(140881, '', 3, 140800),
(140882, '', 3, 140800),
(140901, '', 3, 140900),
(140902, '', 3, 140900),
(140921, '', 3, 140900),
(140922, '', 3, 140900),
(140923, '', 3, 140900),
(140924, '', 3, 140900),
(140925, '', 3, 140900),
(140926, '', 3, 140900),
(140927, '', 3, 140900),
(140928, '', 3, 140900),
(140929, '', 3, 140900),
(140930, '', 3, 140900),
(140931, '', 3, 140900),
(140932, '', 3, 140900),
(140981, '', 3, 140900),
(141001, '', 3, 141000),
(141002, '', 3, 141000),
(141021, '', 3, 141000),
(141022, '', 3, 141000),
(141023, '', 3, 141000),
(141024, '', 3, 141000),
(141025, '', 3, 141000),
(141026, '', 3, 141000),
(141027, '', 3, 141000),
(141028, '', 3, 141000),
(141029, '', 3, 141000),
(141030, '', 3, 141000),
(141031, '', 3, 141000),
(141032, '', 3, 141000),
(141033, '', 3, 141000),
(141034, '', 3, 141000),
(141081, '', 3, 141000),
(141082, '', 3, 141000),
(141101, '', 3, 141100),
(141102, '', 3, 141100),
(141121, '', 3, 141100),
(141122, '', 3, 141100),
(141123, '', 3, 141100),
(141124, '', 3, 141100),
(141125, '', 3, 141100),
(141126, '', 3, 141100),
(141127, '', 3, 141100),
(141128, '', 3, 141100),
(141129, '', 3, 141100),
(141130, '', 3, 141100),
(141181, '', 3, 141100),
(141182, '', 3, 141100),
(150101, '', 3, 150100),
(150102, '', 3, 150100),
(150103, '', 3, 150100),
(150104, '', 3, 150100),
(150105, '', 3, 150100),
(150121, '', 3, 150100),
(150122, '', 3, 150100),
(150123, '', 3, 150100),
(150124, '', 3, 150100),
(150125, '', 3, 150100),
(150201, '', 3, 150200),
(150202, '', 3, 150200),
(150203, '', 3, 150200),
(150204, '', 3, 150200),
(150205, '', 3, 150200),
(150206, '', 3, 150200),
(150207, '', 3, 150200),
(150221, '', 3, 150200),
(150222, '', 3, 150200),
(150223, '', 3, 150200),
(150301, '', 3, 150300),
(150302, '', 3, 150300),
(150303, '', 3, 150300),
(150304, '', 3, 150300),
(150401, '', 3, 150400),
(150402, '', 3, 150400),
(150403, '', 3, 150400),
(150404, '', 3, 150400),
(150421, '', 3, 150400),
(150422, '', 3, 150400),
(150423, '', 3, 150400),
(150424, '', 3, 150400),
(150425, '', 3, 150400),
(150426, '', 3, 150400),
(150428, '', 3, 150400),
(150429, '', 3, 150400),
(150430, '', 3, 150400),
(150501, '', 3, 150500),
(150502, '', 3, 150500),
(150521, '', 3, 150500),
(150522, '', 3, 150500),
(150523, '', 3, 150500),
(150524, '', 3, 150500),
(150525, '', 3, 150500),
(150526, '', 3, 150500),
(150581, '', 3, 150500),
(150602, '', 3, 150600),
(150621, '', 3, 150600),
(150622, '', 3, 150600),
(150623, '', 3, 150600),
(150624, '', 3, 150600),
(150625, '', 3, 150600),
(150626, '', 3, 150600),
(150627, '', 3, 150600),
(150701, '', 3, 150700),
(150702, '', 3, 150700),
(150721, '', 3, 150700),
(150722, '', 3, 150700),
(150723, '', 3, 150700),
(150724, '', 3, 150700),
(150725, '', 3, 150700),
(150726, '', 3, 150700),
(150727, '', 3, 150700),
(150781, '', 3, 150700),
(150782, '', 3, 150700),
(150783, '', 3, 150700),
(150784, '', 3, 150700),
(150785, '', 3, 150700),
(150801, '', 3, 150800),
(150802, '', 3, 150800),
(150821, '', 3, 150800),
(150822, '', 3, 150800),
(150823, '', 3, 150800),
(150824, '', 3, 150800),
(150825, '', 3, 150800),
(150826, '', 3, 150800),
(150901, '', 3, 150900),
(150902, '', 3, 150900),
(150921, '', 3, 150900),
(150922, '', 3, 150900),
(150923, '', 3, 150900),
(150924, '', 3, 150900),
(150925, '', 3, 150900),
(150926, '', 3, 150900),
(150927, '', 3, 150900),
(150928, '', 3, 150900),
(150929, '', 3, 150900),
(150981, '', 3, 150900),
(152201, '', 3, 152200),
(152202, '', 3, 152200),
(152221, '', 3, 152200),
(152222, '', 3, 152200),
(152223, '', 3, 152200),
(152224, '', 3, 152200),
(152501, '', 3, 152500),
(152502, '', 3, 152500),
(152522, '', 3, 152500),
(152523, '', 3, 152500),
(152524, '', 3, 152500),
(152525, '', 3, 152500),
(152526, '', 3, 152500),
(152527, '', 3, 152500),
(152528, '', 3, 152500),
(152529, '', 3, 152500),
(152530, '', 3, 152500),
(152531, '', 3, 152500),
(152921, '', 3, 152900),
(152922, '', 3, 152900),
(152923, '', 3, 152900),
(210101, '', 3, 210100),
(210102, '', 3, 210100),
(210103, '', 3, 210100),
(210104, '', 3, 210100),
(210105, '', 3, 210100),
(210106, '', 3, 210100),
(210111, '', 3, 210100),
(210112, '', 3, 210100),
(210113, '', 3, 210100),
(210114, '', 3, 210100),
(210122, '', 3, 210100),
(210123, '', 3, 210100),
(210124, '', 3, 210100),
(210181, '', 3, 210100),
(210201, '', 3, 210200),
(210202, '', 3, 210200),
(210203, '', 3, 210200),
(210204, '', 3, 210200),
(210211, '', 3, 210200),
(210212, '', 3, 210200),
(210213, '', 3, 210200),
(210224, '', 3, 210200),
(210281, '', 3, 210200),
(210282, '', 3, 210200),
(210283, '', 3, 210200),
(210301, '', 3, 210300),
(210302, '', 3, 210300),
(210303, '', 3, 210300),
(210304, '', 3, 210300),
(210311, '', 3, 210300),
(210321, '', 3, 210300),
(210323, '', 3, 210300),
(210381, '', 3, 210300),
(210401, '', 3, 210400),
(210402, '', 3, 210400),
(210403, '', 3, 210400),
(210404, '', 3, 210400),
(210411, '', 3, 210400),
(210421, '', 3, 210400),
(210422, '', 3, 210400),
(210423, '', 3, 210400),
(210501, '', 3, 210500),
(210502, '', 3, 210500),
(210503, '', 3, 210500),
(210504, '', 3, 210500),
(210505, '', 3, 210500),
(210521, '', 3, 210500),
(210522, '', 3, 210500),
(210601, '', 3, 210600),
(210602, '', 3, 210600),
(210603, '', 3, 210600),
(210604, '', 3, 210600),
(210624, '', 3, 210600),
(210681, '', 3, 210600),
(210682, '', 3, 210600),
(210701, '', 3, 210700),
(210702, '', 3, 210700),
(210703, '', 3, 210700),
(210711, '', 3, 210700),
(210726, '', 3, 210700),
(210727, '', 3, 210700),
(210781, '', 3, 210700),
(210782, '', 3, 210700),
(210801, '', 3, 210800),
(210802, '', 3, 210800),
(210803, '', 3, 210800),
(210804, '', 3, 210800),
(210811, '', 3, 210800),
(210881, '', 3, 210800),
(210882, '', 3, 210800),
(210901, '', 3, 210900),
(210902, '', 3, 210900),
(210903, '', 3, 210900),
(210904, '', 3, 210900),
(210905, '', 3, 210900),
(210911, '', 3, 210900),
(210921, '', 3, 210900),
(210922, '', 3, 210900),
(211001, '', 3, 211000),
(211002, '', 3, 211000),
(211003, '', 3, 211000),
(211004, '', 3, 211000),
(211005, '', 3, 211000),
(211011, '', 3, 211000),
(211021, '', 3, 211000),
(211081, '', 3, 211000),
(211101, '', 3, 211100),
(211102, '', 3, 211100),
(211103, '', 3, 211100),
(211121, '', 3, 211100),
(211122, '', 3, 211100),
(211201, '', 3, 211200),
(211202, '', 3, 211200),
(211204, '', 3, 211200),
(211221, '', 3, 211200),
(211223, '', 3, 211200),
(211224, '', 3, 211200),
(211281, '', 3, 211200),
(211282, '', 3, 211200),
(211301, '', 3, 211300),
(211302, '', 3, 211300),
(211303, '', 3, 211300),
(211321, '', 3, 211300),
(211322, '', 3, 211300),
(211324, '', 3, 211300),
(211381, '', 3, 211300),
(211382, '', 3, 211300),
(211401, '', 3, 211400),
(211402, '', 3, 211400),
(211403, '', 3, 211400),
(211404, '', 3, 211400),
(211421, '', 3, 211400),
(211422, '', 3, 211400),
(211481, '', 3, 211400),
(220101, '', 3, 220100),
(220102, '', 3, 220100),
(220103, '', 3, 220100),
(220104, '', 3, 220100),
(220105, '', 3, 220100),
(220106, '', 3, 220100),
(220112, '', 3, 220100),
(220122, '', 3, 220100),
(220181, '', 3, 220100),
(220182, '', 3, 220100),
(220183, '', 3, 220100),
(220201, '', 3, 220200),
(220202, '', 3, 220200),
(220203, '', 3, 220200),
(220204, '', 3, 220200),
(220211, '', 3, 220200),
(220221, '', 3, 220200),
(220281, '', 3, 220200),
(220282, '', 3, 220200),
(220283, '', 3, 220200),
(220284, '', 3, 220200),
(220301, '', 3, 220300),
(220302, '', 3, 220300),
(220303, '', 3, 220300),
(220322, '', 3, 220300),
(220323, '', 3, 220300),
(220381, '', 3, 220300),
(220382, '', 3, 220300),
(220401, '', 3, 220400),
(220402, '', 3, 220400),
(220403, '', 3, 220400),
(220421, '', 3, 220400),
(220422, '', 3, 220400),
(220501, '', 3, 220500),
(220502, '', 3, 220500),
(220503, '', 3, 220500),
(220521, '', 3, 220500),
(220523, '', 3, 220500),
(220524, '', 3, 220500),
(220581, '', 3, 220500),
(220582, '', 3, 220500),
(220601, '', 3, 220600),
(220602, '', 3, 220600),
(220621, '', 3, 220600),
(220622, '', 3, 220600),
(220623, '', 3, 220600),
(220625, '', 3, 220600),
(220681, '', 3, 220600),
(220701, '', 3, 220700),
(220702, '', 3, 220700),
(220721, '', 3, 220700),
(220722, '', 3, 220700),
(220723, '', 3, 220700),
(220724, '', 3, 220700),
(220801, '', 3, 220800),
(220802, '', 3, 220800),
(220821, '', 3, 220800),
(220822, '', 3, 220800),
(220881, '', 3, 220800),
(220882, '', 3, 220800),
(222401, '', 3, 222400),
(222402, '', 3, 222400),
(222403, '', 3, 222400),
(222404, '', 3, 222400),
(222405, '', 3, 222400),
(222406, '', 3, 222400),
(222424, '', 3, 222400),
(222426, '', 3, 222400),
(230101, '', 3, 230100),
(230102, '', 3, 230100),
(230103, '', 3, 230100),
(230104, '', 3, 230100),
(230106, '', 3, 230100),
(230107, '', 3, 230100),
(230108, '', 3, 230100),
(230109, '', 3, 230100),
(230111, '', 3, 230100),
(230123, '', 3, 230100),
(230124, '', 3, 230100),
(230125, '', 3, 230100),
(230126, '', 3, 230100),
(230127, '', 3, 230100),
(230128, '', 3, 230100),
(230129, '', 3, 230100),
(230181, '', 3, 230100),
(230182, '', 3, 230100),
(230183, '', 3, 230100),
(230184, '', 3, 230100),
(230201, '', 3, 230200),
(230202, '', 3, 230200),
(230203, '', 3, 230200),
(230204, '', 3, 230200),
(230205, '', 3, 230200),
(230206, '', 3, 230200),
(230207, '', 3, 230200),
(230208, '', 3, 230200),
(230221, '', 3, 230200),
(230223, '', 3, 230200),
(230224, '', 3, 230200),
(230225, '', 3, 230200),
(230227, '', 3, 230200),
(230229, '', 3, 230200),
(230230, '', 3, 230200),
(230231, '', 3, 230200),
(230281, '', 3, 230200),
(230301, '', 3, 230300),
(230302, '', 3, 230300),
(230303, '', 3, 230300),
(230304, '', 3, 230300),
(230305, '', 3, 230300),
(230306, '', 3, 230300),
(230307, '', 3, 230300),
(230321, '', 3, 230300),
(230381, '', 3, 230300),
(230382, '', 3, 230300),
(230401, '', 3, 230400),
(230402, '', 3, 230400),
(230403, '', 3, 230400),
(230404, '', 3, 230400),
(230405, '', 3, 230400),
(230406, '', 3, 230400),
(230407, '', 3, 230400),
(230421, '', 3, 230400),
(230422, '', 3, 230400),
(230501, '', 3, 230500),
(230502, '', 3, 230500),
(230503, '', 3, 230500),
(230505, '', 3, 230500),
(230506, '', 3, 230500),
(230521, '', 3, 230500),
(230522, '', 3, 230500),
(230523, '', 3, 230500),
(230524, '', 3, 230500),
(230601, '', 3, 230600),
(230602, '', 3, 230600),
(230603, '', 3, 230600),
(230604, '', 3, 230600),
(230605, '', 3, 230600),
(230606, '', 3, 230600),
(230621, '', 3, 230600),
(230622, '', 3, 230600),
(230623, '', 3, 230600),
(230624, '', 3, 230600),
(230701, '', 3, 230700),
(230702, '', 3, 230700),
(230703, '', 3, 230700),
(230704, '', 3, 230700),
(230705, '', 3, 230700),
(230706, '', 3, 230700),
(230707, '', 3, 230700),
(230708, '', 3, 230700),
(230709, '', 3, 230700),
(230710, '', 3, 230700),
(230711, '', 3, 230700),
(230712, '', 3, 230700),
(230713, '', 3, 230700),
(230714, '', 3, 230700),
(230715, '', 3, 230700),
(230716, '', 3, 230700),
(230722, '', 3, 230700),
(230781, '', 3, 230700),
(230801, '', 3, 230800),
(230802, '', 3, 230800),
(230803, '', 3, 230800),
(230804, '', 3, 230800),
(230805, '', 3, 230800),
(230811, '', 3, 230800),
(230822, '', 3, 230800),
(230826, '', 3, 230800),
(230828, '', 3, 230800),
(230833, '', 3, 230800),
(230881, '', 3, 230800),
(230882, '', 3, 230800),
(230901, '', 3, 230900),
(230902, '', 3, 230900),
(230903, '', 3, 230900),
(230904, '', 3, 230900),
(230921, '', 3, 230900),
(231001, '', 3, 231000),
(231002, '', 3, 231000),
(231003, '', 3, 231000),
(231004, '', 3, 231000),
(231005, '', 3, 231000),
(231024, '', 3, 231000),
(231025, '', 3, 231000),
(231081, '', 3, 231000),
(231083, '', 3, 231000),
(231084, '', 3, 231000),
(231085, '', 3, 231000),
(231101, '', 3, 231100),
(231102, '', 3, 231100),
(231121, '', 3, 231100),
(231123, '', 3, 231100),
(231124, '', 3, 231100),
(231181, '', 3, 231100),
(231182, '', 3, 231100),
(231201, '', 3, 231200),
(231202, '', 3, 231200),
(231221, '', 3, 231200),
(231222, '', 3, 231200),
(231223, '', 3, 231200),
(231224, '', 3, 231200),
(231225, '', 3, 231200),
(231226, '', 3, 231200),
(231281, '', 3, 231200),
(231282, '', 3, 231200),
(231283, '', 3, 231200),
(232721, '', 3, 232700),
(232722, '', 3, 232700),
(232723, '', 3, 232700),
(310101, '', 3, 310100),
(310103, '', 3, 310100),
(310104, '', 3, 310100),
(310105, '', 3, 310100),
(310106, '', 3, 310100),
(310107, '', 3, 310100),
(310108, '', 3, 310100),
(310109, '', 3, 310100),
(310110, '', 3, 310100),
(310112, '', 3, 310100),
(310113, '', 3, 310100),
(310114, '', 3, 310100),
(310115, '', 3, 310100),
(310116, '', 3, 310100),
(310117, '', 3, 310100),
(310118, '', 3, 310100),
(310119, '', 3, 310100),
(310120, '', 3, 310100),
(310230, '', 3, 310200),
(320101, '', 3, 320100),
(320102, '', 3, 320100),
(320103, '', 3, 320100),
(320104, '', 3, 320100),
(320105, '', 3, 320100),
(320106, '', 3, 320100),
(320107, '', 3, 320100),
(320111, '', 3, 320100),
(320113, '', 3, 320100),
(320114, '', 3, 320100),
(320115, '', 3, 320100),
(320116, '', 3, 320100),
(320124, '', 3, 320100),
(320125, '', 3, 320100),
(320201, '', 3, 320200),
(320202, '', 3, 320200),
(320203, '', 3, 320200),
(320204, '', 3, 320200),
(320205, '', 3, 320200),
(320206, '', 3, 320200),
(320211, '', 3, 320200),
(320281, '', 3, 320200),
(320282, '', 3, 320200),
(320301, '', 3, 320300),
(320302, '', 3, 320300),
(320303, '', 3, 320300),
(320304, '', 3, 320300),
(320305, '', 3, 320300),
(320311, '', 3, 320300),
(320321, '', 3, 320300),
(320322, '', 3, 320300),
(320323, '', 3, 320300),
(320324, '', 3, 320300),
(320381, '', 3, 320300),
(320382, '', 3, 320300),
(320401, '', 3, 320400),
(320402, '', 3, 320400),
(320404, '', 3, 320400),
(320405, '', 3, 320400),
(320411, '', 3, 320400),
(320412, '', 3, 320400),
(320481, '', 3, 320400),
(320482, '', 3, 320400),
(320501, '', 3, 320500),
(320502, '', 3, 320500),
(320503, '', 3, 320500),
(320504, '', 3, 320500),
(320505, '', 3, 320500),
(320506, '', 3, 320500),
(320507, '', 3, 320500),
(320581, '', 3, 320500),
(320582, '', 3, 320500),
(320583, '', 3, 320500),
(320584, '', 3, 320500),
(320585, '', 3, 320500),
(320601, '', 3, 320600),
(320602, '', 3, 320600),
(320611, '', 3, 320600),
(320621, '', 3, 320600),
(320623, '', 3, 320600),
(320681, '', 3, 320600),
(320682, '', 3, 320600),
(320683, '', 3, 320600),
(320684, '', 3, 320600),
(320701, '', 3, 320700),
(320703, '', 3, 320700),
(320705, '', 3, 320700),
(320706, '', 3, 320700),
(320721, '', 3, 320700),
(320722, '', 3, 320700),
(320723, '', 3, 320700),
(320724, '', 3, 320700),
(320801, '', 3, 320800),
(320802, '', 3, 320800),
(320803, '', 3, 320800),
(320804, '', 3, 320800),
(320811, '', 3, 320800),
(320826, '', 3, 320800),
(320829, '', 3, 320800),
(320830, '', 3, 320800),
(320831, '', 3, 320800),
(320901, '', 3, 320900),
(320902, '', 3, 320900),
(320903, '', 3, 320900),
(320921, '', 3, 320900),
(320922, '', 3, 320900),
(320923, '', 3, 320900),
(320924, '', 3, 320900),
(320925, '', 3, 320900),
(320981, '', 3, 320900),
(320982, '', 3, 320900),
(321001, '', 3, 321000),
(321002, '', 3, 321000),
(321003, '', 3, 321000),
(321011, '', 3, 321000),
(321023, '', 3, 321000),
(321081, '', 3, 321000),
(321084, '', 3, 321000),
(321088, '', 3, 321000),
(321101, '', 3, 321100),
(321102, '', 3, 321100),
(321111, '', 3, 321100),
(321112, '', 3, 321100),
(321181, '', 3, 321100),
(321182, '', 3, 321100),
(321183, '', 3, 321100),
(321201, '', 3, 321200),
(321202, '', 3, 321200),
(321203, '', 3, 321200),
(321281, '', 3, 321200),
(321282, '', 3, 321200),
(321283, '', 3, 321200),
(321284, '', 3, 321200),
(321301, '', 3, 321300),
(321302, '', 3, 321300),
(321311, '', 3, 321300),
(321322, '', 3, 321300),
(321323, '', 3, 321300),
(321324, '', 3, 321300),
(330101, '', 3, 330100),
(330102, '', 3, 330100),
(330103, '', 3, 330100),
(330104, '', 3, 330100),
(330105, '', 3, 330100),
(330106, '', 3, 330100),
(330108, '', 3, 330100),
(330109, '', 3, 330100),
(330110, '', 3, 330100),
(330122, '', 3, 330100),
(330127, '', 3, 330100),
(330182, '', 3, 330100),
(330183, '', 3, 330100),
(330185, '', 3, 330100),
(330201, '', 3, 330200),
(330203, '', 3, 330200),
(330204, '', 3, 330200),
(330205, '', 3, 330200),
(330206, '', 3, 330200),
(330211, '', 3, 330200),
(330212, '', 3, 330200),
(330225, '', 3, 330200),
(330226, '', 3, 330200),
(330281, '', 3, 330200),
(330282, '', 3, 330200),
(330283, '', 3, 330200),
(330301, '', 3, 330300),
(330302, '', 3, 330300),
(330303, '', 3, 330300),
(330304, '', 3, 330300),
(330322, '', 3, 330300),
(330324, '', 3, 330300),
(330326, '', 3, 330300),
(330327, '', 3, 330300),
(330328, '', 3, 330300),
(330329, '', 3, 330300),
(330381, '', 3, 330300),
(330382, '', 3, 330300),
(330401, '', 3, 330400),
(330402, '', 3, 330400),
(330411, '', 3, 330400),
(330421, '', 3, 330400),
(330424, '', 3, 330400),
(330481, '', 3, 330400),
(330482, '', 3, 330400),
(330483, '', 3, 330400),
(330501, '', 3, 330500),
(330502, '', 3, 330500),
(330503, '', 3, 330500),
(330521, '', 3, 330500),
(330522, '', 3, 330500),
(330523, '', 3, 330500),
(330601, '', 3, 330600),
(330602, '', 3, 330600),
(330621, '', 3, 330600),
(330624, '', 3, 330600),
(330681, '', 3, 330600),
(330682, '', 3, 330600),
(330683, '', 3, 330600),
(330701, '', 3, 330700),
(330702, '', 3, 330700),
(330703, '', 3, 330700),
(330723, '', 3, 330700),
(330726, '', 3, 330700),
(330727, '', 3, 330700),
(330781, '', 3, 330700),
(330782, '', 3, 330700),
(330783, '', 3, 330700),
(330784, '', 3, 330700),
(330801, '', 3, 330800),
(330802, '', 3, 330800),
(330803, '', 3, 330800),
(330822, '', 3, 330800),
(330824, '', 3, 330800),
(330825, '', 3, 330800),
(330881, '', 3, 330800),
(330901, '', 3, 330900),
(330902, '', 3, 330900),
(330903, '', 3, 330900),
(330921, '', 3, 330900),
(330922, '', 3, 330900),
(331001, '', 3, 331000),
(331002, '', 3, 331000),
(331003, '', 3, 331000),
(331004, '', 3, 331000),
(331021, '', 3, 331000),
(331022, '', 3, 331000),
(331023, '', 3, 331000),
(331024, '', 3, 331000),
(331081, '', 3, 331000),
(331082, '', 3, 331000),
(331101, '', 3, 331100),
(331102, '', 3, 331100),
(331121, '', 3, 331100),
(331122, '', 3, 331100),
(331123, '', 3, 331100),
(331124, '', 3, 331100),
(331125, '', 3, 331100),
(331126, '', 3, 331100),
(331127, '', 3, 331100),
(331181, '', 3, 331100),
(340101, '', 3, 340100),
(340102, '', 3, 340100),
(340103, '', 3, 340100),
(340104, '', 3, 340100),
(340111, '', 3, 340100),
(340121, '', 3, 340100),
(340122, '', 3, 340100),
(340123, '', 3, 340100),
(340201, '', 3, 340200),
(340202, '', 3, 340200),
(340203, '', 3, 340200),
(340204, '', 3, 340200),
(340207, '', 3, 340200),
(340221, '', 3, 340200),
(340222, '', 3, 340200),
(340223, '', 3, 340200),
(340301, '', 3, 340300),
(340302, '', 3, 340300),
(340303, '', 3, 340300),
(340304, '', 3, 340300),
(340311, '', 3, 340300),
(340321, '', 3, 340300),
(340322, '', 3, 340300),
(340323, '', 3, 340300),
(340401, '', 3, 340400),
(340402, '', 3, 340400),
(340403, '', 3, 340400),
(340404, '', 3, 340400),
(340405, '', 3, 340400),
(340406, '', 3, 340400),
(340421, '', 3, 340400),
(340501, '', 3, 340500),
(340502, '', 3, 340500),
(340503, '', 3, 340500),
(340504, '', 3, 340500),
(340521, '', 3, 340500),
(340601, '', 3, 340600),
(340602, '', 3, 340600),
(340603, '', 3, 340600),
(340604, '', 3, 340600),
(340621, '', 3, 340600),
(340701, '', 3, 340700),
(340702, '', 3, 340700),
(340703, '', 3, 340700),
(340711, '', 3, 340700),
(340721, '', 3, 340700),
(340801, '', 3, 340800),
(340802, '', 3, 340800),
(340803, '', 3, 340800),
(340811, '', 3, 340800),
(340822, '', 3, 340800),
(340823, '', 3, 340800),
(340824, '', 3, 340800),
(340825, '', 3, 340800),
(340826, '', 3, 340800),
(340827, '', 3, 340800),
(340828, '', 3, 340800),
(340881, '', 3, 340800),
(341001, '', 3, 341000),
(341002, '', 3, 341000),
(341003, '', 3, 341000),
(341004, '', 3, 341000),
(341021, '', 3, 341000),
(341022, '', 3, 341000),
(341023, '', 3, 341000),
(341024, '', 3, 341000),
(341101, '', 3, 341100),
(341102, '', 3, 341100),
(341103, '', 3, 341100),
(341122, '', 3, 341100),
(341124, '', 3, 341100),
(341125, '', 3, 341100),
(341126, '', 3, 341100),
(341181, '', 3, 341100),
(341182, '', 3, 341100),
(341201, '', 3, 341200),
(341202, '', 3, 341200),
(341203, '', 3, 341200),
(341204, '', 3, 341200),
(341221, '', 3, 341200),
(341222, '', 3, 341200),
(341225, '', 3, 341200),
(341226, '', 3, 341200),
(341282, '', 3, 341200),
(341301, '', 3, 341300),
(341302, '', 3, 341300),
(341321, '', 3, 341300),
(341322, '', 3, 341300),
(341323, '', 3, 341300),
(341324, '', 3, 341300),
(341401, '', 3, 340100),
(341402, '', 3, 340100),
(341422, '', 3, 340200),
(341423, '', 3, 340500),
(341424, '', 3, 340500),
(341501, '', 3, 341500),
(341502, '', 3, 341500),
(341503, '', 3, 341500),
(341521, '', 3, 341500),
(341522, '', 3, 341500),
(341523, '', 3, 341500),
(341524, '', 3, 341500),
(341525, '', 3, 341500),
(341601, '', 3, 341600),
(341602, '', 3, 341600),
(341621, '', 3, 341600),
(341622, '', 3, 341600),
(341623, '', 3, 341600),
(341701, '', 3, 341700),
(341702, '', 3, 341700),
(341721, '', 3, 341700),
(341722, '', 3, 341700),
(341723, '', 3, 341700),
(341801, '', 3, 341800),
(341802, '', 3, 341800),
(341821, '', 3, 341800),
(341822, '', 3, 341800),
(341823, '', 3, 341800);
INSERT INTO `thinkox_district` (`id`, `name`, `level`, `upid`) VALUES
(341824, '', 3, 341800),
(341825, '', 3, 341800),
(341881, '', 3, 341800),
(350101, '', 3, 350100),
(350102, '', 3, 350100),
(350103, '', 3, 350100),
(350104, '', 3, 350100),
(350105, '', 3, 350100),
(350111, '', 3, 350100),
(350121, '', 3, 350100),
(350122, '', 3, 350100),
(350123, '', 3, 350100),
(350124, '', 3, 350100),
(350125, '', 3, 350100),
(350128, '', 3, 350100),
(350181, '', 3, 350100),
(350182, '', 3, 350100),
(350201, '', 3, 350200),
(350203, '', 3, 350200),
(350205, '', 3, 350200),
(350206, '', 3, 350200),
(350211, '', 3, 350200),
(350212, '', 3, 350200),
(350213, '', 3, 350200),
(350301, '', 3, 350300),
(350302, '', 3, 350300),
(350303, '', 3, 350300),
(350304, '', 3, 350300),
(350305, '', 3, 350300),
(350322, '', 3, 350300),
(350401, '', 3, 350400),
(350402, '', 3, 350400),
(350403, '', 3, 350400),
(350421, '', 3, 350400),
(350423, '', 3, 350400),
(350424, '', 3, 350400),
(350425, '', 3, 350400),
(350426, '', 3, 350400),
(350427, '', 3, 350400),
(350428, '', 3, 350400),
(350429, '', 3, 350400),
(350430, '', 3, 350400),
(350481, '', 3, 350400),
(350501, '', 3, 350500),
(350502, '', 3, 350500),
(350503, '', 3, 350500),
(350504, '', 3, 350500),
(350505, '', 3, 350500),
(350521, '', 3, 350500),
(350524, '', 3, 350500),
(350525, '', 3, 350500),
(350526, '', 3, 350500),
(350527, '', 3, 350500),
(350581, '', 3, 350500),
(350582, '', 3, 350500),
(350583, '', 3, 350500),
(350601, '', 3, 350600),
(350602, '', 3, 350600),
(350603, '', 3, 350600),
(350622, '', 3, 350600),
(350623, '', 3, 350600),
(350624, '', 3, 350600),
(350625, '', 3, 350600),
(350626, '', 3, 350600),
(350627, '', 3, 350600),
(350628, '', 3, 350600),
(350629, '', 3, 350600),
(350681, '', 3, 350600),
(350701, '', 3, 350700),
(350702, '', 3, 350700),
(350721, '', 3, 350700),
(350722, '', 3, 350700),
(350723, '', 3, 350700),
(350724, '', 3, 350700),
(350725, '', 3, 350700),
(350781, '', 3, 350700),
(350782, '', 3, 350700),
(350783, '', 3, 350700),
(350784, '', 3, 350700),
(350801, '', 3, 350800),
(350802, '', 3, 350800),
(350821, '', 3, 350800),
(350822, '', 3, 350800),
(350823, '', 3, 350800),
(350824, '', 3, 350800),
(350825, '', 3, 350800),
(350881, '', 3, 350800),
(350901, '', 3, 350900),
(350902, '', 3, 350900),
(350921, '', 3, 350900),
(350922, '', 3, 350900),
(350923, '', 3, 350900),
(350924, '', 3, 350900),
(350925, '', 3, 350900),
(350926, '', 3, 350900),
(350981, '', 3, 350900),
(350982, '', 3, 350900),
(360101, '', 3, 360100),
(360102, '', 3, 360100),
(360103, '', 3, 360100),
(360104, '', 3, 360100),
(360105, '', 3, 360100),
(360111, '', 3, 360100),
(360121, '', 3, 360100),
(360122, '', 3, 360100),
(360123, '', 3, 360100),
(360124, '', 3, 360100),
(360201, '', 3, 360200),
(360202, '', 3, 360200),
(360203, '', 3, 360200),
(360222, '', 3, 360200),
(360281, '', 3, 360200),
(360301, '', 3, 360300),
(360302, '', 3, 360300),
(360313, '', 3, 360300),
(360321, '', 3, 360300),
(360322, '', 3, 360300),
(360323, '', 3, 360300),
(360401, '', 3, 360400),
(360402, '', 3, 360400),
(360403, '', 3, 360400),
(360421, '', 3, 360400),
(360423, '', 3, 360400),
(360424, '', 3, 360400),
(360425, '', 3, 360400),
(360426, '', 3, 360400),
(360427, '', 3, 360400),
(360428, '', 3, 360400),
(360429, '', 3, 360400),
(360430, '', 3, 360400),
(360481, '', 3, 360400),
(360501, '', 3, 360500),
(360502, '', 3, 360500),
(360521, '', 3, 360500),
(360601, '', 3, 360600),
(360602, '', 3, 360600),
(360622, '', 3, 360600),
(360681, '', 3, 360600),
(360701, '', 3, 360700),
(360702, '', 3, 360700),
(360721, '', 3, 360700),
(360722, '', 3, 360700),
(360723, '', 3, 360700),
(360724, '', 3, 360700),
(360725, '', 3, 360700),
(360726, '', 3, 360700),
(360727, '', 3, 360700),
(360728, '', 3, 360700),
(360729, '', 3, 360700),
(360730, '', 3, 360700),
(360731, '', 3, 360700),
(360732, '', 3, 360700),
(360733, '', 3, 360700),
(360734, '', 3, 360700),
(360735, '', 3, 360700),
(360781, '', 3, 360700),
(360782, '', 3, 360700),
(360801, '', 3, 360800),
(360802, '', 3, 360800),
(360803, '', 3, 360800),
(360821, '', 3, 360800),
(360822, '', 3, 360800),
(360823, '', 3, 360800),
(360824, '', 3, 360800),
(360825, '', 3, 360800),
(360826, '', 3, 360800),
(360827, '', 3, 360800),
(360828, '', 3, 360800),
(360829, '', 3, 360800),
(360830, '', 3, 360800),
(360881, '', 3, 360800),
(360901, '', 3, 360900),
(360902, '', 3, 360900),
(360921, '', 3, 360900),
(360922, '', 3, 360900),
(360923, '', 3, 360900),
(360924, '', 3, 360900),
(360925, '', 3, 360900),
(360926, '', 3, 360900),
(360981, '', 3, 360900),
(360982, '', 3, 360900),
(360983, '', 3, 360900),
(361001, '', 3, 361000),
(361002, '', 3, 361000),
(361021, '', 3, 361000),
(361022, '', 3, 361000),
(361023, '', 3, 361000),
(361024, '', 3, 361000),
(361025, '', 3, 361000),
(361026, '', 3, 361000),
(361027, '', 3, 361000),
(361028, '', 3, 361000),
(361029, '', 3, 361000),
(361030, '', 3, 361000),
(361101, '', 3, 361100),
(361102, '', 3, 361100),
(361121, '', 3, 361100),
(361122, '', 3, 361100),
(361123, '', 3, 361100),
(361124, '', 3, 361100),
(361125, '', 3, 361100),
(361126, '', 3, 361100),
(361127, '', 3, 361100),
(361128, '', 3, 361100),
(361129, '', 3, 361100),
(361130, '', 3, 361100),
(361181, '', 3, 361100),
(370101, '', 3, 370100),
(370102, '', 3, 370100),
(370103, '', 3, 370100),
(370104, '', 3, 370100),
(370105, '', 3, 370100),
(370112, '', 3, 370100),
(370113, '', 3, 370100),
(370124, '', 3, 370100),
(370125, '', 3, 370100),
(370126, '', 3, 370100),
(370181, '', 3, 370100),
(370201, '', 3, 370200),
(370202, '', 3, 370200),
(370203, '', 3, 370200),
(370205, '', 3, 370200),
(370211, '', 3, 370200),
(370212, '', 3, 370200),
(370213, '', 3, 370200),
(370214, '', 3, 370200),
(370281, '', 3, 370200),
(370282, '', 3, 370200),
(370283, '', 3, 370200),
(370284, '', 3, 370200),
(370285, '', 3, 370200),
(370301, '', 3, 370300),
(370302, '', 3, 370300),
(370303, '', 3, 370300),
(370304, '', 3, 370300),
(370305, '', 3, 370300),
(370306, '', 3, 370300),
(370321, '', 3, 370300),
(370322, '', 3, 370300),
(370323, '', 3, 370300),
(370401, '', 3, 370400),
(370402, '', 3, 370400),
(370403, '', 3, 370400),
(370404, '', 3, 370400),
(370405, '', 3, 370400),
(370406, '', 3, 370400),
(370481, '', 3, 370400),
(370501, '', 3, 370500),
(370502, '', 3, 370500),
(370503, '', 3, 370500),
(370521, '', 3, 370500),
(370522, '', 3, 370500),
(370523, '', 3, 370500),
(370601, '', 3, 370600),
(370602, '', 3, 370600),
(370611, '', 3, 370600),
(370612, '', 3, 370600),
(370613, '', 3, 370600),
(370634, '', 3, 370600),
(370681, '', 3, 370600),
(370682, '', 3, 370600),
(370683, '', 3, 370600),
(370684, '', 3, 370600),
(370685, '', 3, 370600),
(370686, '', 3, 370600),
(370687, '', 3, 370600),
(370701, '', 3, 370700),
(370702, '', 3, 370700),
(370703, '', 3, 370700),
(370704, '', 3, 370700),
(370705, '', 3, 370700),
(370724, '', 3, 370700),
(370725, '', 3, 370700),
(370781, '', 3, 370700),
(370782, '', 3, 370700),
(370783, '', 3, 370700),
(370784, '', 3, 370700),
(370785, '', 3, 370700),
(370786, '', 3, 370700),
(370801, '', 3, 370800),
(370802, '', 3, 370800),
(370811, '', 3, 370800),
(370826, '', 3, 370800),
(370827, '', 3, 370800),
(370828, '', 3, 370800),
(370829, '', 3, 370800),
(370830, '', 3, 370800),
(370831, '', 3, 370800),
(370832, '', 3, 370800),
(370881, '', 3, 370800),
(370882, '', 3, 370800),
(370883, '', 3, 370800),
(370901, '', 3, 370900),
(370902, '', 3, 370900),
(370903, '', 3, 370900),
(370921, '', 3, 370900),
(370923, '', 3, 370900),
(370982, '', 3, 370900),
(370983, '', 3, 370900),
(371001, '', 3, 371000),
(371002, '', 3, 371000),
(371081, '', 3, 371000),
(371082, '', 3, 371000),
(371083, '', 3, 371000),
(371101, '', 3, 371100),
(371102, '', 3, 371100),
(371103, '', 3, 371100),
(371121, '', 3, 371100),
(371122, '', 3, 371100),
(371201, '', 3, 371200),
(371202, '', 3, 371200),
(371203, '', 3, 371200),
(371301, '', 3, 371300),
(371302, '', 3, 371300),
(371311, '', 3, 371300),
(371312, '', 3, 371300),
(371321, '', 3, 371300),
(371322, '', 3, 371300),
(371323, '', 3, 371300),
(371324, '', 3, 371300),
(371325, '', 3, 371300),
(371326, '', 3, 371300),
(371327, '', 3, 371300),
(371328, '', 3, 371300),
(371329, '', 3, 371300),
(371401, '', 3, 371400),
(371402, '', 3, 371400),
(371421, '', 3, 371400),
(371422, '', 3, 371400),
(371423, '', 3, 371400),
(371424, '', 3, 371400),
(371425, '', 3, 371400),
(371426, '', 3, 371400),
(371427, '', 3, 371400),
(371428, '', 3, 371400),
(371481, '', 3, 371400),
(371482, '', 3, 371400),
(371501, '', 3, 371500),
(371502, '', 3, 371500),
(371521, '', 3, 371500),
(371522, '', 3, 371500),
(371523, '', 3, 371500),
(371524, '', 3, 371500),
(371525, '', 3, 371500),
(371526, '', 3, 371500),
(371581, '', 3, 371500),
(371601, '', 3, 371600),
(371602, '', 3, 371600),
(371621, '', 3, 371600),
(371622, '', 3, 371600),
(371623, '', 3, 371600),
(371624, '', 3, 371600),
(371625, '', 3, 371600),
(371626, '', 3, 371600),
(371701, '', 3, 371700),
(371702, '', 3, 371700),
(371721, '', 3, 371700),
(371722, '', 3, 371700),
(371723, '', 3, 371700),
(371724, '', 3, 371700),
(371725, '', 3, 371700),
(371726, '', 3, 371700),
(371727, '', 3, 371700),
(371728, '', 3, 371700),
(410101, '', 3, 410100),
(410102, '', 3, 410100),
(410103, '', 3, 410100),
(410104, '', 3, 410100),
(410105, '', 3, 410100),
(410106, '', 3, 410100),
(410108, '', 3, 410100),
(410122, '', 3, 410100),
(410181, '', 3, 410100),
(410182, '', 3, 410100),
(410183, '', 3, 410100),
(410184, '', 3, 410100),
(410185, '', 3, 410100),
(410201, '', 3, 410200),
(410202, '', 3, 410200),
(410203, '', 3, 410200),
(410204, '', 3, 410200),
(410205, '', 3, 410200),
(410211, '', 3, 410200),
(410221, '', 3, 410200),
(410222, '', 3, 410200),
(410223, '', 3, 410200),
(410224, '', 3, 410200),
(410225, '', 3, 410200),
(410301, '', 3, 410300),
(410302, '', 3, 410300),
(410303, '', 3, 410300),
(410304, '', 3, 410300),
(410305, '', 3, 410300),
(410306, '', 3, 410300),
(410307, '', 3, 410300),
(410322, '', 3, 410300),
(410323, '', 3, 410300),
(410324, '', 3, 410300),
(410325, '', 3, 410300),
(410326, '', 3, 410300),
(410327, '', 3, 410300),
(410328, '', 3, 410300),
(410329, '', 3, 410300),
(410381, '', 3, 410300),
(410401, '', 3, 410400),
(410402, '', 3, 410400),
(410403, '', 3, 410400),
(410404, '', 3, 410400),
(410411, '', 3, 410400),
(410421, '', 3, 410400),
(410422, '', 3, 410400),
(410423, '', 3, 410400),
(410425, '', 3, 410400),
(410481, '', 3, 410400),
(410482, '', 3, 410400),
(410501, '', 3, 410500),
(410502, '', 3, 410500),
(410503, '', 3, 410500),
(410505, '', 3, 410500),
(410506, '', 3, 410500),
(410522, '', 3, 410500),
(410523, '', 3, 410500),
(410526, '', 3, 410500),
(410527, '', 3, 410500),
(410581, '', 3, 410500),
(410601, '', 3, 410600),
(410602, '', 3, 410600),
(410603, '', 3, 410600),
(410611, '', 3, 410600),
(410621, '', 3, 410600),
(410622, '', 3, 410600),
(410701, '', 3, 410700),
(410702, '', 3, 410700),
(410703, '', 3, 410700),
(410704, '', 3, 410700),
(410711, '', 3, 410700),
(410721, '', 3, 410700),
(410724, '', 3, 410700),
(410725, '', 3, 410700),
(410726, '', 3, 410700),
(410727, '', 3, 410700),
(410728, '', 3, 410700),
(410781, '', 3, 410700),
(410782, '', 3, 410700),
(410801, '', 3, 410800),
(410802, '', 3, 410800),
(410803, '', 3, 410800),
(410804, '', 3, 410800),
(410811, '', 3, 410800),
(410821, '', 3, 410800),
(410822, '', 3, 410800),
(410823, '', 3, 410800),
(410825, '', 3, 410800),
(410881, '', 3, 410800),
(410882, '', 3, 410800),
(410883, '', 3, 410800),
(410901, '', 3, 410900),
(410902, '', 3, 410900),
(410922, '', 3, 410900),
(410923, '', 3, 410900),
(410926, '', 3, 410900),
(410927, '', 3, 410900),
(410928, '', 3, 410900),
(411001, '', 3, 411000),
(411002, '', 3, 411000),
(411023, '', 3, 411000),
(411024, '', 3, 411000),
(411025, '', 3, 411000),
(411081, '', 3, 411000),
(411082, '', 3, 411000),
(411101, '', 3, 411100),
(411102, '', 3, 411100),
(411103, '', 3, 411100),
(411104, '', 3, 411100),
(411121, '', 3, 411100),
(411122, '', 3, 411100),
(411201, '', 3, 411200),
(411202, '', 3, 411200),
(411221, '', 3, 411200),
(411222, '', 3, 411200),
(411224, '', 3, 411200),
(411281, '', 3, 411200),
(411282, '', 3, 411200),
(411301, '', 3, 411300),
(411302, '', 3, 411300),
(411303, '', 3, 411300),
(411321, '', 3, 411300),
(411322, '', 3, 411300),
(411323, '', 3, 411300),
(411324, '', 3, 411300),
(411325, '', 3, 411300),
(411326, '', 3, 411300),
(411327, '', 3, 411300),
(411328, '', 3, 411300),
(411329, '', 3, 411300),
(411330, '', 3, 411300),
(411381, '', 3, 411300),
(411401, '', 3, 411400),
(411402, '', 3, 411400),
(411403, '', 3, 411400),
(411421, '', 3, 411400),
(411422, '', 3, 411400),
(411423, '', 3, 411400),
(411424, '', 3, 411400),
(411425, '', 3, 411400),
(411426, '', 3, 411400),
(411481, '', 3, 411400),
(411501, '', 3, 411500),
(411502, '', 3, 411500),
(411503, '', 3, 411500),
(411521, '', 3, 411500),
(411522, '', 3, 411500),
(411523, '', 3, 411500),
(411524, '', 3, 411500),
(411525, '', 3, 411500),
(411526, '', 3, 411500),
(411527, '', 3, 411500),
(411528, '', 3, 411500),
(411601, '', 3, 411600),
(411602, '', 3, 411600),
(411621, '', 3, 411600),
(411622, '', 3, 411600),
(411623, '', 3, 411600),
(411624, '', 3, 411600),
(411625, '', 3, 411600),
(411626, '', 3, 411600),
(411627, '', 3, 411600),
(411628, '', 3, 411600),
(411681, '', 3, 411600),
(411701, '', 3, 411700),
(411702, '', 3, 411700),
(411721, '', 3, 411700),
(411722, '', 3, 411700),
(411723, '', 3, 411700),
(411724, '', 3, 411700),
(411725, '', 3, 411700),
(411726, '', 3, 411700),
(411727, '', 3, 411700),
(411728, '', 3, 411700),
(411729, '', 3, 411700),
(420101, '', 3, 420100),
(420102, '', 3, 420100),
(420103, '', 3, 420100),
(420104, '', 3, 420100),
(420105, '', 3, 420100),
(420106, '', 3, 420100),
(420107, '', 3, 420100),
(420111, '', 3, 420100),
(420112, '', 3, 420100),
(420113, '', 3, 420100),
(420114, '', 3, 420100),
(420115, '', 3, 420100),
(420116, '', 3, 420100),
(420117, '', 3, 420100),
(420201, '', 3, 420200),
(420202, '', 3, 420200),
(420203, '', 3, 420200),
(420204, '', 3, 420200),
(420205, '', 3, 420200),
(420222, '', 3, 420200),
(420281, '', 3, 420200),
(420301, '', 3, 420300),
(420302, '', 3, 420300),
(420303, '', 3, 420300),
(420321, '', 3, 420300),
(420322, '', 3, 420300),
(420323, '', 3, 420300),
(420324, '', 3, 420300),
(420325, '', 3, 420300),
(420381, '', 3, 420300),
(420501, '', 3, 420500),
(420502, '', 3, 420500),
(420503, '', 3, 420500),
(420504, '', 3, 420500),
(420505, '', 3, 420500),
(420506, '', 3, 420500),
(420525, '', 3, 420500),
(420526, '', 3, 420500),
(420527, '', 3, 420500),
(420528, '', 3, 420500),
(420529, '', 3, 420500),
(420581, '', 3, 420500),
(420582, '', 3, 420500),
(420583, '', 3, 420500),
(420601, '', 3, 420600),
(420602, '', 3, 420600),
(420606, '', 3, 420600),
(420607, '', 3, 420600),
(420624, '', 3, 420600),
(420625, '', 3, 420600),
(420626, '', 3, 420600),
(420682, '', 3, 420600),
(420683, '', 3, 420600),
(420684, '', 3, 420600),
(420701, '', 3, 420700),
(420702, '', 3, 420700),
(420703, '', 3, 420700),
(420704, '', 3, 420700),
(420801, '', 3, 420800),
(420802, '', 3, 420800),
(420804, '', 3, 420800),
(420821, '', 3, 420800),
(420822, '', 3, 420800),
(420881, '', 3, 420800),
(420901, '', 3, 420900),
(420902, '', 3, 420900),
(420921, '', 3, 420900),
(420922, '', 3, 420900),
(420923, '', 3, 420900),
(420981, '', 3, 420900),
(420982, '', 3, 420900),
(420984, '', 3, 420900),
(421001, '', 3, 421000),
(421002, '', 3, 421000),
(421003, '', 3, 421000),
(421022, '', 3, 421000),
(421023, '', 3, 421000),
(421024, '', 3, 421000),
(421081, '', 3, 421000),
(421083, '', 3, 421000),
(421087, '', 3, 421000),
(421101, '', 3, 421100),
(421102, '', 3, 421100),
(421121, '', 3, 421100),
(421122, '', 3, 421100),
(421123, '', 3, 421100),
(421124, '', 3, 421100),
(421125, '', 3, 421100),
(421126, '', 3, 421100),
(421127, '', 3, 421100),
(421181, '', 3, 421100),
(421182, '', 3, 421100),
(421201, '', 3, 421200),
(421202, '', 3, 421200),
(421221, '', 3, 421200),
(421222, '', 3, 421200),
(421223, '', 3, 421200),
(421224, '', 3, 421200),
(421281, '', 3, 421200),
(421301, '', 3, 421300),
(421302, '', 3, 421300),
(421381, '', 3, 421300),
(422801, '', 3, 422800),
(422802, '', 3, 422800),
(422822, '', 3, 422800),
(422823, '', 3, 422800),
(422825, '', 3, 422800),
(422826, '', 3, 422800),
(422827, '', 3, 422800),
(422828, '', 3, 422800),
(429004, '', 3, 429000),
(429005, '', 3, 429000),
(429006, '', 3, 429000),
(429021, '', 3, 429000),
(430101, '', 3, 430100),
(430102, '', 3, 430100),
(430103, '', 3, 430100),
(430104, '', 3, 430100),
(430105, '', 3, 430100),
(430111, '', 3, 430100),
(430121, '', 3, 430100),
(430122, '', 3, 430100),
(430124, '', 3, 430100),
(430181, '', 3, 430100),
(430201, '', 3, 430200),
(430202, '', 3, 430200),
(430203, '', 3, 430200),
(430204, '', 3, 430200),
(430211, '', 3, 430200),
(430221, '', 3, 430200),
(430223, '', 3, 430200),
(430224, '', 3, 430200),
(430225, '', 3, 430200),
(430281, '', 3, 430200),
(430301, '', 3, 430300),
(430302, '', 3, 430300),
(430304, '', 3, 430300),
(430321, '', 3, 430300),
(430381, '', 3, 430300),
(430382, '', 3, 430300),
(430401, '', 3, 430400),
(430405, '', 3, 430400),
(430406, '', 3, 430400),
(430407, '', 3, 430400),
(430408, '', 3, 430400),
(430412, '', 3, 430400),
(430421, '', 3, 430400),
(430422, '', 3, 430400),
(430423, '', 3, 430400),
(430424, '', 3, 430400),
(430426, '', 3, 430400),
(430481, '', 3, 430400),
(430482, '', 3, 430400),
(430501, '', 3, 430500),
(430502, '', 3, 430500),
(430503, '', 3, 430500),
(430511, '', 3, 430500),
(430521, '', 3, 430500),
(430522, '', 3, 430500),
(430523, '', 3, 430500),
(430524, '', 3, 430500),
(430525, '', 3, 430500),
(430527, '', 3, 430500),
(430528, '', 3, 430500),
(430529, '', 3, 430500),
(430581, '', 3, 430500),
(430601, '', 3, 430600),
(430602, '', 3, 430600),
(430603, '', 3, 430600),
(430611, '', 3, 430600),
(430621, '', 3, 430600),
(430623, '', 3, 430600),
(430624, '', 3, 430600),
(430626, '', 3, 430600),
(430681, '', 3, 430600),
(430682, '', 3, 430600),
(430701, '', 3, 430700),
(430702, '', 3, 430700),
(430703, '', 3, 430700),
(430721, '', 3, 430700),
(430722, '', 3, 430700),
(430723, '', 3, 430700),
(430724, '', 3, 430700),
(430725, '', 3, 430700),
(430726, '', 3, 430700),
(430781, '', 3, 430700),
(430801, '', 3, 430800),
(430802, '', 3, 430800),
(430811, '', 3, 430800),
(430821, '', 3, 430800),
(430822, '', 3, 430800),
(430901, '', 3, 430900),
(430902, '', 3, 430900),
(430903, '', 3, 430900),
(430921, '', 3, 430900),
(430922, '', 3, 430900),
(430923, '', 3, 430900),
(430981, '', 3, 430900),
(431001, '', 3, 431000),
(431002, '', 3, 431000),
(431003, '', 3, 431000),
(431021, '', 3, 431000),
(431022, '', 3, 431000),
(431023, '', 3, 431000),
(431024, '', 3, 431000),
(431025, '', 3, 431000),
(431026, '', 3, 431000),
(431027, '', 3, 431000),
(431028, '', 3, 431000),
(431081, '', 3, 431000),
(431101, '', 3, 431100),
(431102, '', 3, 431100),
(431103, '', 3, 431100),
(431121, '', 3, 431100),
(431122, '', 3, 431100),
(431123, '', 3, 431100),
(431124, '', 3, 431100),
(431125, '', 3, 431100),
(431126, '', 3, 431100),
(431127, '', 3, 431100),
(431128, '', 3, 431100),
(431129, '', 3, 431100),
(431201, '', 3, 431200),
(431202, '', 3, 431200),
(431221, '', 3, 431200),
(431222, '', 3, 431200),
(431223, '', 3, 431200),
(431224, '', 3, 431200),
(431225, '', 3, 431200),
(431226, '', 3, 431200),
(431227, '', 3, 431200),
(431228, '', 3, 431200),
(431229, '', 3, 431200),
(431230, '', 3, 431200),
(431281, '', 3, 431200),
(431301, '', 3, 431300),
(431302, '', 3, 431300),
(431321, '', 3, 431300),
(431322, '', 3, 431300),
(431381, '', 3, 431300),
(431382, '', 3, 431300),
(433101, '', 3, 433100),
(433122, '', 3, 433100),
(433123, '', 3, 433100),
(433124, '', 3, 433100),
(433125, '', 3, 433100),
(433126, '', 3, 433100),
(433127, '', 3, 433100),
(433130, '', 3, 433100),
(440101, '', 3, 440100),
(440102, '', 3, 440100),
(440103, '', 3, 440100),
(440104, '', 3, 440100),
(440105, '', 3, 440100),
(440106, '', 3, 440100),
(440107, '', 3, 440100),
(440111, '', 3, 440100),
(440112, '', 3, 440100),
(440113, '', 3, 440100),
(440114, '', 3, 440100),
(440183, '', 3, 440100),
(440184, '', 3, 440100),
(440201, '', 3, 440200),
(440203, '', 3, 440200),
(440204, '', 3, 440200),
(440205, '', 3, 440200),
(440222, '', 3, 440200),
(440224, '', 3, 440200),
(440229, '', 3, 440200),
(440232, '', 3, 440200),
(440233, '', 3, 440200),
(440281, '', 3, 440200),
(440282, '', 3, 440200),
(440301, '', 3, 440300),
(440303, '', 3, 440300),
(440304, '', 3, 440300),
(440305, '', 3, 440300),
(440306, '', 3, 440300),
(440307, '', 3, 440300),
(440308, '', 3, 440300),
(440401, '', 3, 440400),
(440402, '', 3, 440400),
(440403, '', 3, 440400),
(440404, '', 3, 440400),
(440501, '', 3, 440500),
(440507, '', 3, 440500),
(440511, '', 3, 440500),
(440512, '', 3, 440500),
(440513, '', 3, 440500),
(440514, '', 3, 440500),
(440515, '', 3, 440500),
(440523, '', 3, 440500),
(440601, '', 3, 440600),
(440604, '', 3, 440600),
(440605, '', 3, 440600),
(440606, '', 3, 440600),
(440607, '', 3, 440600),
(440608, '', 3, 440600),
(440701, '', 3, 440700),
(440703, '', 3, 440700),
(440704, '', 3, 440700),
(440705, '', 3, 440700),
(440781, '', 3, 440700),
(440783, '', 3, 440700),
(440784, '', 3, 440700),
(440785, '', 3, 440700),
(440801, '', 3, 440800),
(440802, '', 3, 440800),
(440803, '', 3, 440800),
(440804, '', 3, 440800),
(440811, '', 3, 440800),
(440823, '', 3, 440800),
(440825, '', 3, 440800),
(440881, '', 3, 440800),
(440882, '', 3, 440800),
(440883, '', 3, 440800),
(440901, '', 3, 440900),
(440902, '', 3, 440900),
(440903, '', 3, 440900),
(440923, '', 3, 440900),
(440981, '', 3, 440900),
(440982, '', 3, 440900),
(440983, '', 3, 440900),
(441201, '', 3, 441200),
(441202, '', 3, 441200),
(441203, '', 3, 441200),
(441223, '', 3, 441200),
(441224, '', 3, 441200),
(441225, '', 3, 441200),
(441226, '', 3, 441200),
(441283, '', 3, 441200),
(441284, '', 3, 441200),
(441301, '', 3, 441300),
(441302, '', 3, 441300),
(441303, '', 3, 441300),
(441322, '', 3, 441300),
(441323, '', 3, 441300),
(441324, '', 3, 441300),
(441401, '', 3, 441400),
(441402, '', 3, 441400),
(441421, '', 3, 441400),
(441422, '', 3, 441400),
(441423, '', 3, 441400),
(441424, '', 3, 441400),
(441426, '', 3, 441400),
(441427, '', 3, 441400),
(441481, '', 3, 441400),
(441501, '', 3, 441500),
(441502, '', 3, 441500),
(441521, '', 3, 441500),
(441523, '', 3, 441500),
(441581, '', 3, 441500),
(441601, '', 3, 441600),
(441602, '', 3, 441600),
(441621, '', 3, 441600),
(441622, '', 3, 441600),
(441623, '', 3, 441600),
(441624, '', 3, 441600),
(441625, '', 3, 441600),
(441701, '', 3, 441700),
(441702, '', 3, 441700),
(441721, '', 3, 441700),
(441723, '', 3, 441700),
(441781, '', 3, 441700),
(441801, '', 3, 441800),
(441802, '', 3, 441800),
(441821, '', 3, 441800),
(441823, '', 3, 441800),
(441825, '', 3, 441800),
(441826, '', 3, 441800),
(441827, '', 3, 441800),
(441881, '', 3, 441800),
(441882, '', 3, 441800),
(445101, '', 3, 445100),
(445102, '', 3, 445100),
(445121, '', 3, 445100),
(445122, '', 3, 445100),
(445201, '', 3, 445200),
(445202, '', 3, 445200),
(445221, '', 3, 445200),
(445222, '', 3, 445200),
(445224, '', 3, 445200),
(445281, '', 3, 445200),
(445301, '', 3, 445300),
(445302, '', 3, 445300),
(445321, '', 3, 445300),
(445322, '', 3, 445300),
(445323, '', 3, 445300),
(445381, '', 3, 445300),
(450101, '', 3, 450100),
(450102, '', 3, 450100),
(450103, '', 3, 450100),
(450105, '', 3, 450100),
(450107, '', 3, 450100),
(450108, '', 3, 450100),
(450109, '', 3, 450100),
(450122, '', 3, 450100),
(450123, '', 3, 450100),
(450124, '', 3, 450100),
(450125, '', 3, 450100),
(450126, '', 3, 450100),
(450127, '', 3, 450100),
(450201, '', 3, 450200),
(450202, '', 3, 450200),
(450203, '', 3, 450200),
(450204, '', 3, 450200),
(450205, '', 3, 450200),
(450221, '', 3, 450200),
(450222, '', 3, 450200),
(450223, '', 3, 450200),
(450224, '', 3, 450200),
(450225, '', 3, 450200),
(450226, '', 3, 450200),
(450301, '', 3, 450300),
(450302, '', 3, 450300),
(450303, '', 3, 450300),
(450304, '', 3, 450300),
(450305, '', 3, 450300),
(450311, '', 3, 450300),
(450321, '', 3, 450300),
(450322, '', 3, 450300),
(450323, '', 3, 450300),
(450324, '', 3, 450300),
(450325, '', 3, 450300),
(450326, '', 3, 450300),
(450327, '', 3, 450300),
(450328, '', 3, 450300),
(450329, '', 3, 450300),
(450330, '', 3, 450300),
(450331, '', 3, 450300),
(450332, '', 3, 450300),
(450401, '', 3, 450400),
(450403, '', 3, 450400),
(450404, '', 3, 450400),
(450405, '', 3, 450400),
(450421, '', 3, 450400),
(450422, '', 3, 450400),
(450423, '', 3, 450400),
(450481, '', 3, 450400),
(450501, '', 3, 450500),
(450502, '', 3, 450500),
(450503, '', 3, 450500),
(450512, '', 3, 450500),
(450521, '', 3, 450500),
(450601, '', 3, 450600),
(450602, '', 3, 450600),
(450603, '', 3, 450600),
(450621, '', 3, 450600),
(450681, '', 3, 450600),
(450701, '', 3, 450700),
(450702, '', 3, 450700),
(450703, '', 3, 450700),
(450721, '', 3, 450700),
(450722, '', 3, 450700),
(450801, '', 3, 450800),
(450802, '', 3, 450800),
(450803, '', 3, 450800),
(450804, '', 3, 450800),
(450821, '', 3, 450800),
(450881, '', 3, 450800),
(450901, '', 3, 450900),
(450902, '', 3, 450900),
(450921, '', 3, 450900),
(450922, '', 3, 450900),
(450923, '', 3, 450900),
(450924, '', 3, 450900),
(450981, '', 3, 450900),
(451001, '', 3, 451000),
(451002, '', 3, 451000),
(451021, '', 3, 451000),
(451022, '', 3, 451000),
(451023, '', 3, 451000),
(451024, '', 3, 451000),
(451025, '', 3, 451000),
(451026, '', 3, 451000),
(451027, '', 3, 451000),
(451028, '', 3, 451000),
(451029, '', 3, 451000),
(451030, '', 3, 451000),
(451031, '', 3, 451000),
(451101, '', 3, 451100),
(451102, '', 3, 451100),
(451121, '', 3, 451100),
(451122, '', 3, 451100),
(451123, '', 3, 451100),
(451201, '', 3, 451200),
(451202, '', 3, 451200),
(451221, '', 3, 451200),
(451222, '', 3, 451200),
(451223, '', 3, 451200),
(451224, '', 3, 451200),
(451225, '', 3, 451200),
(451226, '', 3, 451200),
(451227, '', 3, 451200),
(451228, '', 3, 451200),
(451229, '', 3, 451200),
(451281, '', 3, 451200),
(451301, '', 3, 451300),
(451302, '', 3, 451300),
(451321, '', 3, 451300),
(451322, '', 3, 451300),
(451323, '', 3, 451300),
(451324, '', 3, 451300),
(451381, '', 3, 451300),
(451401, '', 3, 451400),
(451402, '', 3, 451400),
(451421, '', 3, 451400),
(451422, '', 3, 451400),
(451423, '', 3, 451400),
(451424, '', 3, 451400),
(451425, '', 3, 451400),
(451481, '', 3, 451400),
(460101, '', 3, 460100),
(460105, '', 3, 460100),
(460106, '', 3, 460100),
(460107, '', 3, 460100),
(460108, '', 3, 460100),
(460201, '', 3, 460200),
(469001, '', 3, 469000),
(469002, '', 3, 469000),
(469003, '', 3, 469000),
(469005, '', 3, 469000),
(469006, '', 3, 469000),
(469007, '', 3, 469000),
(469025, '', 3, 469000),
(469026, '', 3, 469000),
(469027, '', 3, 469000),
(469028, '', 3, 469000),
(469030, '', 3, 469000),
(469031, '', 3, 469000),
(469033, '', 3, 469000),
(469034, '', 3, 469000),
(469035, '', 3, 469000),
(469036, '', 3, 469000),
(469037, '', 3, 469000),
(469038, '', 3, 469000),
(469039, '', 3, 469000),
(500101, '', 3, 500100),
(500102, '', 3, 500100),
(500103, '', 3, 500100),
(500104, '', 3, 500100),
(500105, '', 3, 500100),
(500106, '', 3, 500100),
(500107, '', 3, 500100),
(500108, '', 3, 500100),
(500109, '', 3, 500100),
(500110, '', 3, 500100),
(500111, '', 3, 500100),
(500112, '', 3, 500100),
(500113, '', 3, 500100),
(500114, '', 3, 500100),
(500115, '', 3, 500100),
(500222, '', 3, 500200),
(500223, '', 3, 500200),
(500224, '', 3, 500200),
(500225, '', 3, 500200),
(500226, '', 3, 500200),
(500227, '', 3, 500200),
(500228, '', 3, 500200),
(500229, '', 3, 500200),
(500230, '', 3, 500200),
(500231, '', 3, 500200),
(500232, '', 3, 500200),
(500233, '', 3, 500200),
(500234, '', 3, 500200),
(500235, '', 3, 500200),
(500236, '', 3, 500200),
(500237, '', 3, 500200),
(500238, '', 3, 500200),
(500240, '', 3, 500200),
(500241, '', 3, 500200),
(500242, '', 3, 500200),
(500243, '', 3, 500200),
(500381, '', 3, 500300),
(500382, '', 3, 500300),
(500383, '', 3, 500300),
(500384, '', 3, 500300),
(510101, '', 3, 510100),
(510104, '', 3, 510100),
(510105, '', 3, 510100),
(510106, '', 3, 510100),
(510107, '', 3, 510100),
(510108, '', 3, 510100),
(510112, '', 3, 510100),
(510113, '', 3, 510100),
(510114, '', 3, 510100),
(510115, '', 3, 510100),
(510121, '', 3, 510100),
(510122, '', 3, 510100),
(510124, '', 3, 510100),
(510129, '', 3, 510100),
(510131, '', 3, 510100),
(510132, '', 3, 510100),
(510181, '', 3, 510100),
(510182, '', 3, 510100),
(510183, '', 3, 510100),
(510184, '', 3, 510100),
(510301, '', 3, 510300),
(510302, '', 3, 510300),
(510303, '', 3, 510300),
(510304, '', 3, 510300),
(510311, '', 3, 510300),
(510321, '', 3, 510300),
(510322, '', 3, 510300),
(510401, '', 3, 510400),
(510402, '', 3, 510400),
(510403, '', 3, 510400),
(510411, '', 3, 510400),
(510421, '', 3, 510400),
(510422, '', 3, 510400),
(510501, '', 3, 510500),
(510502, '', 3, 510500),
(510503, '', 3, 510500),
(510504, '', 3, 510500),
(510521, '', 3, 510500),
(510522, '', 3, 510500),
(510524, '', 3, 510500),
(510525, '', 3, 510500),
(510601, '', 3, 510600),
(510603, '', 3, 510600),
(510623, '', 3, 510600),
(510626, '', 3, 510600),
(510681, '', 3, 510600),
(510682, '', 3, 510600),
(510683, '', 3, 510600),
(510701, '', 3, 510700),
(510703, '', 3, 510700),
(510704, '', 3, 510700),
(510722, '', 3, 510700),
(510723, '', 3, 510700),
(510724, '', 3, 510700),
(510725, '', 3, 510700),
(510726, '', 3, 510700),
(510727, '', 3, 510700),
(510781, '', 3, 510700),
(510801, '', 3, 510800),
(510802, '', 3, 510800),
(510811, '', 3, 510800),
(510812, '', 3, 510800),
(510821, '', 3, 510800),
(510822, '', 3, 510800),
(510823, '', 3, 510800),
(510824, '', 3, 510800),
(510901, '', 3, 510900),
(510903, '', 3, 510900),
(510904, '', 3, 510900),
(510921, '', 3, 510900),
(510922, '', 3, 510900),
(510923, '', 3, 510900),
(511001, '', 3, 511000),
(511002, '', 3, 511000),
(511011, '', 3, 511000),
(511024, '', 3, 511000),
(511025, '', 3, 511000),
(511028, '', 3, 511000),
(511101, '', 3, 511100),
(511102, '', 3, 511100),
(511111, '', 3, 511100),
(511112, '', 3, 511100),
(511113, '', 3, 511100),
(511123, '', 3, 511100),
(511124, '', 3, 511100),
(511126, '', 3, 511100),
(511129, '', 3, 511100),
(511132, '', 3, 511100),
(511133, '', 3, 511100),
(511181, '', 3, 511100),
(511301, '', 3, 511300),
(511302, '', 3, 511300),
(511303, '', 3, 511300),
(511304, '', 3, 511300),
(511321, '', 3, 511300),
(511322, '', 3, 511300),
(511323, '', 3, 511300),
(511324, '', 3, 511300),
(511325, '', 3, 511300),
(511381, '', 3, 511300),
(511401, '', 3, 511400),
(511402, '', 3, 511400),
(511421, '', 3, 511400),
(511422, '', 3, 511400),
(511423, '', 3, 511400),
(511424, '', 3, 511400),
(511425, '', 3, 511400),
(511501, '', 3, 511500),
(511502, '', 3, 511500),
(511521, '', 3, 511500),
(511522, '', 3, 511500),
(511523, '', 3, 511500),
(511524, '', 3, 511500),
(511525, '', 3, 511500),
(511526, '', 3, 511500),
(511527, '', 3, 511500),
(511528, '', 3, 511500),
(511529, '', 3, 511500),
(511601, '', 3, 511600),
(511602, '', 3, 511600),
(511621, '', 3, 511600),
(511622, '', 3, 511600),
(511623, '', 3, 511600),
(511681, '', 3, 511600),
(511701, '', 3, 511700),
(511702, '', 3, 511700),
(511721, '', 3, 511700),
(511722, '', 3, 511700),
(511723, '', 3, 511700),
(511724, '', 3, 511700),
(511725, '', 3, 511700),
(511781, '', 3, 511700),
(511801, '', 3, 511800),
(511802, '', 3, 511800),
(511821, '', 3, 511800),
(511822, '', 3, 511800),
(511823, '', 3, 511800),
(511824, '', 3, 511800),
(511825, '', 3, 511800),
(511826, '', 3, 511800),
(511827, '', 3, 511800),
(511901, '', 3, 511900),
(511902, '', 3, 511900),
(511921, '', 3, 511900),
(511922, '', 3, 511900),
(511923, '', 3, 511900),
(512001, '', 3, 512000),
(512002, '', 3, 512000),
(512021, '', 3, 512000),
(512022, '', 3, 512000),
(512081, '', 3, 512000),
(513221, '', 3, 513200),
(513222, '', 3, 513200),
(513223, '', 3, 513200),
(513224, '', 3, 513200),
(513225, '', 3, 513200),
(513226, '', 3, 513200),
(513227, '', 3, 513200),
(513228, '', 3, 513200),
(513229, '', 3, 513200),
(513230, '', 3, 513200),
(513231, '', 3, 513200),
(513232, '', 3, 513200),
(513233, '', 3, 513200),
(513321, '', 3, 513300),
(513322, '', 3, 513300),
(513323, '', 3, 513300),
(513324, '', 3, 513300),
(513325, '', 3, 513300),
(513326, '', 3, 513300),
(513327, '', 3, 513300),
(513328, '', 3, 513300),
(513329, '', 3, 513300),
(513330, '', 3, 513300),
(513331, '', 3, 513300),
(513332, '', 3, 513300),
(513333, '', 3, 513300),
(513334, '', 3, 513300),
(513335, '', 3, 513300),
(513336, '', 3, 513300),
(513337, '', 3, 513300),
(513338, '', 3, 513300),
(513401, '', 3, 513400),
(513422, '', 3, 513400),
(513423, '', 3, 513400),
(513424, '', 3, 513400),
(513425, '', 3, 513400),
(513426, '', 3, 513400),
(513427, '', 3, 513400),
(513428, '', 3, 513400),
(513429, '', 3, 513400),
(513430, '', 3, 513400),
(513431, '', 3, 513400),
(513432, '', 3, 513400),
(513433, '', 3, 513400),
(513434, '', 3, 513400),
(513435, '', 3, 513400),
(513436, '', 3, 513400),
(513437, '', 3, 513400),
(520101, '', 3, 520100),
(520102, '', 3, 520100),
(520103, '', 3, 520100),
(520111, '', 3, 520100),
(520112, '', 3, 520100),
(520113, '', 3, 520100),
(520114, '', 3, 520100),
(520121, '', 3, 520100),
(520122, '', 3, 520100),
(520123, '', 3, 520100),
(520181, '', 3, 520100),
(520201, '', 3, 520200),
(520203, '', 3, 520200),
(520221, '', 3, 520200),
(520222, '', 3, 520200),
(520301, '', 3, 520300),
(520302, '', 3, 520300),
(520303, '', 3, 520300),
(520321, '', 3, 520300),
(520322, '', 3, 520300),
(520323, '', 3, 520300),
(520324, '', 3, 520300),
(520325, '', 3, 520300),
(520326, '', 3, 520300),
(520327, '', 3, 520300),
(520328, '', 3, 520300),
(520329, '', 3, 520300),
(520330, '', 3, 520300),
(520381, '', 3, 520300),
(520382, '', 3, 520300),
(520401, '', 3, 520400),
(520402, '', 3, 520400),
(520421, '', 3, 520400),
(520422, '', 3, 520400),
(520423, '', 3, 520400),
(520424, '', 3, 520400),
(520425, '', 3, 520400),
(522201, '', 3, 522200),
(522222, '', 3, 522200),
(522223, '', 3, 522200),
(522224, '', 3, 522200),
(522225, '', 3, 522200),
(522226, '', 3, 522200),
(522227, '', 3, 522200),
(522228, '', 3, 522200),
(522229, '', 3, 522200),
(522230, '', 3, 522200),
(522301, '', 3, 522300),
(522322, '', 3, 522300),
(522323, '', 3, 522300),
(522324, '', 3, 522300),
(522325, '', 3, 522300),
(522326, '', 3, 522300),
(522327, '', 3, 522300),
(522328, '', 3, 522300),
(522401, '', 3, 522400),
(522422, '', 3, 522400),
(522423, '', 3, 522400),
(522424, '', 3, 522400),
(522425, '', 3, 522400),
(522426, '', 3, 522400),
(522427, '', 3, 522400),
(522428, '', 3, 522400),
(522601, '', 3, 522600),
(522622, '', 3, 522600),
(522623, '', 3, 522600),
(522624, '', 3, 522600),
(522625, '', 3, 522600),
(522626, '', 3, 522600),
(522627, '', 3, 522600),
(522628, '', 3, 522600),
(522629, '', 3, 522600),
(522630, '', 3, 522600),
(522631, '', 3, 522600),
(522632, '', 3, 522600),
(522633, '', 3, 522600),
(522634, '', 3, 522600),
(522635, '', 3, 522600),
(522636, '', 3, 522600),
(522701, '', 3, 522700),
(522702, '', 3, 522700),
(522722, '', 3, 522700),
(522723, '', 3, 522700),
(522725, '', 3, 522700),
(522726, '', 3, 522700),
(522727, '', 3, 522700),
(522728, '', 3, 522700),
(522729, '', 3, 522700),
(522730, '', 3, 522700),
(522731, '', 3, 522700),
(522732, '', 3, 522700),
(530101, '', 3, 530100),
(530102, '', 3, 530100),
(530103, '', 3, 530100),
(530111, '', 3, 530100),
(530112, '', 3, 530100),
(530113, '', 3, 530100),
(530121, '', 3, 530100),
(530122, '', 3, 530100),
(530124, '', 3, 530100),
(530125, '', 3, 530100),
(530126, '', 3, 530100),
(530127, '', 3, 530100),
(530128, '', 3, 530100),
(530129, '', 3, 530100),
(530181, '', 3, 530100),
(530301, '', 3, 530300),
(530302, '', 3, 530300),
(530321, '', 3, 530300),
(530322, '', 3, 530300),
(530323, '', 3, 530300),
(530324, '', 3, 530300),
(530325, '', 3, 530300),
(530326, '', 3, 530300),
(530328, '', 3, 530300),
(530381, '', 3, 530300),
(530401, '', 3, 530400),
(530402, '', 3, 530400),
(530421, '', 3, 530400),
(530422, '', 3, 530400),
(530423, '', 3, 530400),
(530424, '', 3, 530400),
(530425, '', 3, 530400),
(530426, '', 3, 530400),
(530427, '', 3, 530400),
(530428, '', 3, 530400),
(530501, '', 3, 530500),
(530502, '', 3, 530500),
(530521, '', 3, 530500),
(530522, '', 3, 530500),
(530523, '', 3, 530500),
(530524, '', 3, 530500),
(530601, '', 3, 530600),
(530602, '', 3, 530600),
(530621, '', 3, 530600),
(530622, '', 3, 530600),
(530623, '', 3, 530600),
(530624, '', 3, 530600),
(530625, '', 3, 530600),
(530626, '', 3, 530600),
(530627, '', 3, 530600),
(530628, '', 3, 530600),
(530629, '', 3, 530600),
(530630, '', 3, 530600),
(530701, '', 3, 530700),
(530702, '', 3, 530700),
(530721, '', 3, 530700),
(530722, '', 3, 530700),
(530723, '', 3, 530700),
(530724, '', 3, 530700),
(530801, '', 3, 530800),
(530802, '', 3, 530800),
(530821, '', 3, 530800),
(530822, '', 3, 530800),
(530823, '', 3, 530800),
(530824, '', 3, 530800),
(530825, '', 3, 530800),
(530826, '', 3, 530800),
(530827, '', 3, 530800),
(530828, '', 3, 530800),
(530829, '', 3, 530800),
(530901, '', 3, 530900),
(530902, '', 3, 530900),
(530921, '', 3, 530900),
(530922, '', 3, 530900),
(530923, '', 3, 530900),
(530924, '', 3, 530900),
(530925, '', 3, 530900),
(530926, '', 3, 530900),
(530927, '', 3, 530900),
(532301, '', 3, 532300),
(532322, '', 3, 532300),
(532323, '', 3, 532300),
(532324, '', 3, 532300),
(532325, '', 3, 532300),
(532326, '', 3, 532300),
(532327, '', 3, 532300),
(532328, '', 3, 532300),
(532329, '', 3, 532300),
(532331, '', 3, 532300),
(532501, '', 3, 532500),
(532502, '', 3, 532500),
(532522, '', 3, 532500),
(532523, '', 3, 532500),
(532524, '', 3, 532500),
(532525, '', 3, 532500),
(532526, '', 3, 532500),
(532527, '', 3, 532500),
(532528, '', 3, 532500),
(532529, '', 3, 532500),
(532530, '', 3, 532500),
(532531, '', 3, 532500),
(532532, '', 3, 532500),
(532621, '', 3, 532600),
(532622, '', 3, 532600),
(532623, '', 3, 532600),
(532624, '', 3, 532600),
(532625, '', 3, 532600),
(532626, '', 3, 532600),
(532627, '', 3, 532600),
(532628, '', 3, 532600),
(532801, '', 3, 532800),
(532822, '', 3, 532800);
INSERT INTO `thinkox_district` (`id`, `name`, `level`, `upid`) VALUES
(532823, '', 3, 532800),
(532901, '', 3, 532900),
(532922, '', 3, 532900),
(532923, '', 3, 532900),
(532924, '', 3, 532900),
(532925, '', 3, 532900),
(532926, '', 3, 532900),
(532927, '', 3, 532900),
(532928, '', 3, 532900),
(532929, '', 3, 532900),
(532930, '', 3, 532900),
(532931, '', 3, 532900),
(532932, '', 3, 532900),
(533102, '', 3, 533100),
(533103, '', 3, 533100),
(533122, '', 3, 533100),
(533123, '', 3, 533100),
(533124, '', 3, 533100),
(533321, '', 3, 533300),
(533323, '', 3, 533300),
(533324, '', 3, 533300),
(533325, '', 3, 533300),
(533421, '', 3, 533400),
(533422, '', 3, 533400),
(533423, '', 3, 533400),
(540101, '', 3, 540100),
(540102, '', 3, 540100),
(540121, '', 3, 540100),
(540122, '', 3, 540100),
(540123, '', 3, 540100),
(540124, '', 3, 540100),
(540125, '', 3, 540100),
(540126, '', 3, 540100),
(540127, '', 3, 540100),
(542121, '', 3, 542100),
(542122, '', 3, 542100),
(542123, '', 3, 542100),
(542124, '', 3, 542100),
(542125, '', 3, 542100),
(542126, '', 3, 542100),
(542127, '', 3, 542100),
(542128, '', 3, 542100),
(542129, '', 3, 542100),
(542132, '', 3, 542100),
(542133, '', 3, 542100),
(542221, '', 3, 542200),
(542222, '', 3, 542200),
(542223, '', 3, 542200),
(542224, '', 3, 542200),
(542225, '', 3, 542200),
(542226, '', 3, 542200),
(542227, '', 3, 542200),
(542228, '', 3, 542200),
(542229, '', 3, 542200),
(542231, '', 3, 542200),
(542232, '', 3, 542200),
(542233, '', 3, 542200),
(542301, '', 3, 542300),
(542322, '', 3, 542300),
(542323, '', 3, 542300),
(542324, '', 3, 542300),
(542325, '', 3, 542300),
(542326, '', 3, 542300),
(542327, '', 3, 542300),
(542328, '', 3, 542300),
(542329, '', 3, 542300),
(542330, '', 3, 542300),
(542331, '', 3, 542300),
(542332, '', 3, 542300),
(542333, '', 3, 542300),
(542334, '', 3, 542300),
(542335, '', 3, 542300),
(542336, '', 3, 542300),
(542337, '', 3, 542300),
(542338, '', 3, 542300),
(542421, '', 3, 542400),
(542422, '', 3, 542400),
(542423, '', 3, 542400),
(542424, '', 3, 542400),
(542425, '', 3, 542400),
(542426, '', 3, 542400),
(542427, '', 3, 542400),
(542428, '', 3, 542400),
(542429, '', 3, 542400),
(542430, '', 3, 542400),
(542521, '', 3, 542500),
(542522, '', 3, 542500),
(542523, '', 3, 542500),
(542524, '', 3, 542500),
(542525, '', 3, 542500),
(542526, '', 3, 542500),
(542527, '', 3, 542500),
(542621, '', 3, 542600),
(542622, '', 3, 542600),
(542623, '', 3, 542600),
(542624, '', 3, 542600),
(542625, '', 3, 542600),
(542626, '', 3, 542600),
(542627, '', 3, 542600),
(610101, '', 3, 610100),
(610102, '', 3, 610100),
(610103, '', 3, 610100),
(610104, '', 3, 610100),
(610111, '', 3, 610100),
(610112, '', 3, 610100),
(610113, '', 3, 610100),
(610114, '', 3, 610100),
(610115, '', 3, 610100),
(610116, '', 3, 610100),
(610122, '', 3, 610100),
(610124, '', 3, 610100),
(610125, '', 3, 610100),
(610126, '', 3, 610100),
(610201, '', 3, 610200),
(610202, '', 3, 610200),
(610203, '', 3, 610200),
(610204, '', 3, 610200),
(610222, '', 3, 610200),
(610301, '', 3, 610300),
(610302, '', 3, 610300),
(610303, '', 3, 610300),
(610304, '', 3, 610300),
(610322, '', 3, 610300),
(610323, '', 3, 610300),
(610324, '', 3, 610300),
(610326, '', 3, 610300),
(610327, '', 3, 610300),
(610328, '', 3, 610300),
(610329, '', 3, 610300),
(610330, '', 3, 610300),
(610331, '', 3, 610300),
(610401, '', 3, 610400),
(610402, '', 3, 610400),
(610403, '', 3, 610400),
(610404, '', 3, 610400),
(610422, '', 3, 610400),
(610423, '', 3, 610400),
(610424, '', 3, 610400),
(610425, '', 3, 610400),
(610426, '', 3, 610400),
(610427, '', 3, 610400),
(610428, '', 3, 610400),
(610429, '', 3, 610400),
(610430, '', 3, 610400),
(610431, '', 3, 610400),
(610481, '', 3, 610400),
(610501, '', 3, 610500),
(610502, '', 3, 610500),
(610521, '', 3, 610500),
(610522, '', 3, 610500),
(610523, '', 3, 610500),
(610524, '', 3, 610500),
(610525, '', 3, 610500),
(610526, '', 3, 610500),
(610527, '', 3, 610500),
(610528, '', 3, 610500),
(610581, '', 3, 610500),
(610582, '', 3, 610500),
(610601, '', 3, 610600),
(610602, '', 3, 610600),
(610621, '', 3, 610600),
(610622, '', 3, 610600),
(610623, '', 3, 610600),
(610624, '', 3, 610600),
(610625, '', 3, 610600),
(610626, '', 3, 610600),
(610627, '', 3, 610600),
(610628, '', 3, 610600),
(610629, '', 3, 610600),
(610630, '', 3, 610600),
(610631, '', 3, 610600),
(610632, '', 3, 610600),
(610701, '', 3, 610700),
(610702, '', 3, 610700),
(610721, '', 3, 610700),
(610722, '', 3, 610700),
(610723, '', 3, 610700),
(610724, '', 3, 610700),
(610725, '', 3, 610700),
(610726, '', 3, 610700),
(610727, '', 3, 610700),
(610728, '', 3, 610700),
(610729, '', 3, 610700),
(610730, '', 3, 610700),
(610801, '', 3, 610800),
(610802, '', 3, 610800),
(610821, '', 3, 610800),
(610822, '', 3, 610800),
(610823, '', 3, 610800),
(610824, '', 3, 610800),
(610825, '', 3, 610800),
(610826, '', 3, 610800),
(610827, '', 3, 610800),
(610828, '', 3, 610800),
(610829, '', 3, 610800),
(610830, '', 3, 610800),
(610831, '', 3, 610800),
(610901, '', 3, 610900),
(610902, '', 3, 610900),
(610921, '', 3, 610900),
(610922, '', 3, 610900),
(610923, '', 3, 610900),
(610924, '', 3, 610900),
(610925, '', 3, 610900),
(610926, '', 3, 610900),
(610927, '', 3, 610900),
(610928, '', 3, 610900),
(610929, '', 3, 610900),
(611001, '', 3, 611000),
(611002, '', 3, 611000),
(611021, '', 3, 611000),
(611022, '', 3, 611000),
(611023, '', 3, 611000),
(611024, '', 3, 611000),
(611025, '', 3, 611000),
(611026, '', 3, 611000),
(620101, '', 3, 620100),
(620102, '', 3, 620100),
(620103, '', 3, 620100),
(620104, '', 3, 620100),
(620105, '', 3, 620100),
(620111, '', 3, 620100),
(620121, '', 3, 620100),
(620122, '', 3, 620100),
(620123, '', 3, 620100),
(620201, '', 3, 620200),
(620301, '', 3, 620300),
(620302, '', 3, 620300),
(620321, '', 3, 620300),
(620401, '', 3, 620400),
(620402, '', 3, 620400),
(620403, '', 3, 620400),
(620421, '', 3, 620400),
(620422, '', 3, 620400),
(620423, '', 3, 620400),
(620501, '', 3, 620500),
(620502, '', 3, 620500),
(620503, '', 3, 620500),
(620521, '', 3, 620500),
(620522, '', 3, 620500),
(620523, '', 3, 620500),
(620524, '', 3, 620500),
(620525, '', 3, 620500),
(620601, '', 3, 620600),
(620602, '', 3, 620600),
(620621, '', 3, 620600),
(620622, '', 3, 620600),
(620623, '', 3, 620600),
(620701, '', 3, 620700),
(620702, '', 3, 620700),
(620721, '', 3, 620700),
(620722, '', 3, 620700),
(620723, '', 3, 620700),
(620724, '', 3, 620700),
(620725, '', 3, 620700),
(620801, '', 3, 620800),
(620802, '', 3, 620800),
(620821, '', 3, 620800),
(620822, '', 3, 620800),
(620823, '', 3, 620800),
(620824, '', 3, 620800),
(620825, '', 3, 620800),
(620826, '', 3, 620800),
(620901, '', 3, 620900),
(620902, '', 3, 620900),
(620921, '', 3, 620900),
(620922, '', 3, 620900),
(620923, '', 3, 620900),
(620924, '', 3, 620900),
(620981, '', 3, 620900),
(620982, '', 3, 620900),
(621001, '', 3, 621000),
(621002, '', 3, 621000),
(621021, '', 3, 621000),
(621022, '', 3, 621000),
(621023, '', 3, 621000),
(621024, '', 3, 621000),
(621025, '', 3, 621000),
(621026, '', 3, 621000),
(621027, '', 3, 621000),
(621101, '', 3, 621100),
(621102, '', 3, 621100),
(621121, '', 3, 621100),
(621122, '', 3, 621100),
(621123, '', 3, 621100),
(621124, '', 3, 621100),
(621125, '', 3, 621100),
(621126, '', 3, 621100),
(621201, '', 3, 621200),
(621202, '', 3, 621200),
(621221, '', 3, 621200),
(621222, '', 3, 621200),
(621223, '', 3, 621200),
(621224, '', 3, 621200),
(621225, '', 3, 621200),
(621226, '', 3, 621200),
(621227, '', 3, 621200),
(621228, '', 3, 621200),
(622901, '', 3, 622900),
(622921, '', 3, 622900),
(622922, '', 3, 622900),
(622923, '', 3, 622900),
(622924, '', 3, 622900),
(622925, '', 3, 622900),
(622926, '', 3, 622900),
(622927, '', 3, 622900),
(623001, '', 3, 623000),
(623021, '', 3, 623000),
(623022, '', 3, 623000),
(623023, '', 3, 623000),
(623024, '', 3, 623000),
(623025, '', 3, 623000),
(623026, '', 3, 623000),
(623027, '', 3, 623000),
(630101, '', 3, 630100),
(630102, '', 3, 630100),
(630103, '', 3, 630100),
(630104, '', 3, 630100),
(630105, '', 3, 630100),
(630121, '', 3, 630100),
(630122, '', 3, 630100),
(630123, '', 3, 630100),
(632121, '', 3, 632100),
(632122, '', 3, 632100),
(632123, '', 3, 632100),
(632126, '', 3, 632100),
(632127, '', 3, 632100),
(632128, '', 3, 632100),
(632221, '', 3, 632200),
(632222, '', 3, 632200),
(632223, '', 3, 632200),
(632224, '', 3, 632200),
(632321, '', 3, 632300),
(632322, '', 3, 632300),
(632323, '', 3, 632300),
(632324, '', 3, 632300),
(632521, '', 3, 632500),
(632522, '', 3, 632500),
(632523, '', 3, 632500),
(632524, '', 3, 632500),
(632525, '', 3, 632500),
(632621, '', 3, 632600),
(632622, '', 3, 632600),
(632623, '', 3, 632600),
(632624, '', 3, 632600),
(632625, '', 3, 632600),
(632626, '', 3, 632600),
(632721, '', 3, 632700),
(632722, '', 3, 632700),
(632723, '', 3, 632700),
(632724, '', 3, 632700),
(632725, '', 3, 632700),
(632726, '', 3, 632700),
(632801, '', 3, 632800),
(632802, '', 3, 632800),
(632821, '', 3, 632800),
(632822, '', 3, 632800),
(632823, '', 3, 632800),
(640101, '', 3, 640100),
(640104, '', 3, 640100),
(640105, '', 3, 640100),
(640106, '', 3, 640100),
(640121, '', 3, 640100),
(640122, '', 3, 640100),
(640181, '', 3, 640100),
(640201, '', 3, 640200),
(640202, '', 3, 640200),
(640205, '', 3, 640200),
(640221, '', 3, 640200),
(640301, '', 3, 640300),
(640302, '', 3, 640300),
(640323, '', 3, 640300),
(640324, '', 3, 640300),
(640381, '', 3, 640300),
(640401, '', 3, 640400),
(640402, '', 3, 640400),
(640422, '', 3, 640400),
(640423, '', 3, 640400),
(640424, '', 3, 640400),
(640425, '', 3, 640400),
(640501, '', 3, 640500),
(640502, '', 3, 640500),
(640521, '', 3, 640500),
(640522, '', 3, 640500),
(650101, '', 3, 650100),
(650102, '', 3, 650100),
(650103, '', 3, 650100),
(650104, '', 3, 650100),
(650105, '', 3, 650100),
(650106, '', 3, 650100),
(650107, '', 3, 650100),
(650108, '', 3, 650100),
(650121, '', 3, 650100),
(650201, '', 3, 650200),
(650202, '', 3, 650200),
(650203, '', 3, 650200),
(650204, '', 3, 650200),
(650205, '', 3, 650200),
(652101, '', 3, 652100),
(652122, '', 3, 652100),
(652123, '', 3, 652100),
(652201, '', 3, 652200),
(652222, '', 3, 652200),
(652223, '', 3, 652200),
(652301, '', 3, 652300),
(652302, '', 3, 652300),
(652303, '', 3, 652300),
(652323, '', 3, 652300),
(652324, '', 3, 652300),
(652325, '', 3, 652300),
(652327, '', 3, 652300),
(652328, '', 3, 652300),
(652701, '', 3, 652700),
(652722, '', 3, 652700),
(652723, '', 3, 652700),
(652801, '', 3, 652800),
(652822, '', 3, 652800),
(652823, '', 3, 652800),
(652824, '', 3, 652800),
(652825, '', 3, 652800),
(652826, '', 3, 652800),
(652827, '', 3, 652800),
(652828, '', 3, 652800),
(652829, '', 3, 652800),
(652901, '', 3, 652900),
(652922, '', 3, 652900),
(652923, '', 3, 652900),
(652924, '', 3, 652900),
(652925, '', 3, 652900),
(652926, '', 3, 652900),
(652927, '', 3, 652900),
(652928, '', 3, 652900),
(652929, '', 3, 652900),
(653001, '', 3, 653000),
(653022, '', 3, 653000),
(653023, '', 3, 653000),
(653024, '', 3, 653000),
(653101, '', 3, 653100),
(653121, '', 3, 653100),
(653122, '', 3, 653100),
(653123, '', 3, 653100),
(653124, '', 3, 653100),
(653125, '', 3, 653100),
(653126, '', 3, 653100),
(653127, '', 3, 653100),
(653128, '', 3, 653100),
(653129, '', 3, 653100),
(653130, '', 3, 653100),
(653131, '', 3, 653100),
(653201, '', 3, 653200),
(653221, '', 3, 653200),
(653222, '', 3, 653200),
(653223, '', 3, 653200),
(653224, '', 3, 653200),
(653225, '', 3, 653200),
(653226, '', 3, 653200),
(653227, '', 3, 653200),
(654002, '', 3, 654000),
(654003, '', 3, 654000),
(654021, '', 3, 654000),
(654022, '', 3, 654000),
(654023, '', 3, 654000),
(654024, '', 3, 654000),
(654025, '', 3, 654000),
(654026, '', 3, 654000),
(654027, '', 3, 654000),
(654028, '', 3, 654000),
(654201, '', 3, 654200),
(654202, '', 3, 654200),
(654221, '', 3, 654200),
(654223, '', 3, 654200),
(654224, '', 3, 654200),
(654225, '', 3, 654200),
(654226, '', 3, 654200),
(654301, '', 3, 654300),
(654321, '', 3, 654300),
(654322, '', 3, 654300),
(654323, '', 3, 654300),
(654324, '', 3, 654300),
(654325, '', 3, 654300),
(654326, '', 3, 654300),
(659001, '', 3, 659000),
(659002, '', 3, 659000),
(659003, '', 3, 659000),
(659004, '', 3, 659000),
(810001, '', 2, 810000),
(810002, '', 3, 810001),
(810003, '', 3, 810001),
(810004, '', 3, 810001),
(810005, '', 3, 810001),
(810006, '', 3, 810001),
(810007, '', 3, 810001),
(810008, '', 3, 810001),
(810009, '', 3, 810001),
(810010, '', 3, 810001),
(810011, '', 3, 810001),
(810012, '', 3, 810001),
(810013, '', 3, 810001),
(810014, '', 3, 810001),
(810015, '', 3, 810001),
(810016, '', 3, 810001),
(810017, '', 3, 810001),
(810018, '', 3, 810001),
(810019, '', 3, 810001),
(820001, '', 2, 820000),
(820002, '', 3, 820001),
(710001, '', 2, 710000),
(710002, '', 3, 710001),
(710003, '', 2, 710000),
(910005, '', 3, 442000),
(710004, '', 3, 710003),
(910006, '', 3, 441900);
|
package com.suscipio_solutions.consecro_mud.Commands;
import java.util.Vector;
import com.suscipio_solutions.consecro_mud.MOBS.interfaces.MOB;
import com.suscipio_solutions.consecro_mud.core.CMParms;
@SuppressWarnings("rawtypes")
public class NoFollow extends Follow
{
public NoFollow(){}
private final String[] access=I(new String[]{"NOFOLLOW","NOFOL"});
@Override public String[] getAccessWords(){return access;}
@Override
public boolean execute(MOB mob, Vector commands, int metaFlags)
throws java.io.IOException
{
if((commands.size()>1)&&(commands.elementAt(0) instanceof String))
{
if(((String)commands.elementAt(0)).equalsIgnoreCase("UNFOLLOW"))
{
unfollow(mob,((commands.size()>1)&&(commands.elementAt(1) instanceof String)&&(((String)commands.elementAt(1)).equalsIgnoreCase("QUIETLY"))));
return false;
}
MOB M=mob.fetchFollower(CMParms.combine(commands,1));
if((M==null)&&(mob.location()!=null))
{
M=mob.location().fetchInhabitant(CMParms.combine(commands,1));
if(M!=null)
mob.tell(L("@x1 is not following you!",M.name(mob)));
else
mob.tell(L("There is noone here called '@x1' following you!",CMParms.combine(commands,1)));
return false;
}
if((mob.location()!=null)&&(M!=null)&&(M.amFollowing()==mob))
{
nofollow(M,true,false);
return true;
}
mob.tell(L("There is noone called '@x1' following you!",CMParms.combine(commands,1)));
return false;
}
if(!mob.isAttribute(MOB.Attrib.NOFOLLOW))
{
mob.setAttribute(MOB.Attrib.NOFOLLOW,true);
//unfollow(mob,false);
mob.tell(L("You are no longer accepting new followers."));
}
else
{
mob.setAttribute(MOB.Attrib.NOFOLLOW,false);
mob.tell(L("You are now accepting new followers."));
}
return false;
}
@Override public boolean canBeOrdered(){return true;}
}
|
package org.dbflute.erflute.db.impl.mysql;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import org.dbflute.erflute.editor.model.dbimport.DBObject;
import org.dbflute.erflute.editor.model.dbimport.<API key>;
public class <API key> extends <API key> {
@Override
protected List<DBObject> importObjects(String[] types, String dbObjectType) throws SQLException {
final List<DBObject> list = new ArrayList<>();
ResultSet resultSet = null;
if (schemaList.isEmpty()) {
schemaList.add(null);
}
final String catalog = (8 <= metaData.<API key>()) ? dbSetting.getDatabase() : null;
for (final String schemaPattern : schemaList) {
try {
resultSet = metaData.getTables(catalog, schemaPattern, null, types);
while (resultSet.next()) {
final String schema = resultSet.getString("TABLE_SCHEM");
final String name = resultSet.getString("TABLE_NAME");
if (DBObject.TYPE_TABLE.equals(dbObjectType)) {
try {
<API key>(con, schema, name);
} catch (final SQLException e) {
e.printStackTrace();
continue;
}
}
final DBObject dbObject = new DBObject(schema, name, dbObjectType);
list.add(dbObject);
}
} finally {
if (resultSet != null) {
resultSet.close();
resultSet = null;
}
}
}
return list;
}
}
|
// THIS FILE WAS AUTO-GENERATED BY ADKGEN -- DO NOT MODIFY!
using System;
using System.Text;
using System.Security.Permissions;
using System.Runtime.Serialization;
using OpenADK.Library;
using OpenADK.Library.Global;
using OpenADK.Library.au.Common;
namespace OpenADK.Library.au.School{
<summary>A MediumOfInstruction</summary>
<remarks>
<para>Author: Generated by adkgen</para>
<para>Version: 2.6</para>
<para>Since: 2.6</para>
</remarks>
[Serializable]
public class MediumOfInstruction : SifKeyedElement
{
<summary>
Creates an instance of a MediumOfInstruction
</summary>
public MediumOfInstruction() : base ( SchoolDTD.MEDIUMOFINSTRUCTION ){}
<summary>
Constructor that accepts values for all mandatory fields
</summary>
<param name="code">A Code</param>
public MediumOfInstruction( <API key> code ) : base( SchoolDTD.MEDIUMOFINSTRUCTION )
{
this.SetCode( code );
}
<summary>
Constructor used by the .Net Serialization formatter
</summary>
[SecurityPermission( SecurityAction.Demand, <API key>=true )]
protected MediumOfInstruction( SerializationInfo info, StreamingContext context ) : base( info, context ) {}
<summary>
Gets the metadata fields that make up the key of this object
</summary>
<value>
an array of metadata fields that make up the object's key
</value>
public override IElementDef[] KeyFields {
get { return new IElementDef[] { SchoolDTD.<API key> }; }
}
<summary>
Gets or sets the value of the <c><Code></c> element.
</summary>
<value> The <c>Code</c> element of this object.</value>
<remarks>
<para>Version: 2.6</para>
<para>Since: 2.6</para>
</remarks>
public string Code
{
get
{
return GetFieldValue( SchoolDTD.<API key> );
}
set
{
SetField( SchoolDTD.<API key>, value );
}
}
<summary>
Sets the value of the <c><Code></c> element.
</summary>
<param name="val">A <API key> object</param>
<remarks>
<para>Version: 2.6</para>
<para>Since: 2.6</para>
</remarks>
public void SetCode( <API key> val )
{
SetField( SchoolDTD.<API key>, val );
}
<summary>
Gets or sets the value of the <c><OtherCodeList></c> element.
</summary>
<value> An OtherCodeList </value>
<remarks>
<para>To remove the <c>OtherCodeList</c>, set <c>OtherCodeList</c> to <c>null</c></para>
<para>Version: 2.6</para>
<para>Since: 2.6</para>
</remarks>
public OtherCodeList OtherCodeList
{
get
{
return (OtherCodeList)GetChild( SchoolDTD.<API key>);
}
set
{
RemoveChild( SchoolDTD.<API key>);
if( value != null)
{
AddChild( SchoolDTD.<API key>, value );
}
}
}
}}
|
package org.gradle.test.performance.<API key>.p36;
import org.junit.Test;
import static org.junit.Assert.*;
public class Test730 {
Production730 objectUnderTest = new Production730();
@Test
public void testProperty0() {
String value = "value";
objectUnderTest.setProperty0(value);
assertEquals(value, objectUnderTest.getProperty0());
}
@Test
public void testProperty1() {
String value = "value";
objectUnderTest.setProperty1(value);
assertEquals(value, objectUnderTest.getProperty1());
}
@Test
public void testProperty2() {
String value = "value";
objectUnderTest.setProperty2(value);
assertEquals(value, objectUnderTest.getProperty2());
}
@Test
public void testProperty3() {
String value = "value";
objectUnderTest.setProperty3(value);
assertEquals(value, objectUnderTest.getProperty3());
}
@Test
public void testProperty4() {
String value = "value";
objectUnderTest.setProperty4(value);
assertEquals(value, objectUnderTest.getProperty4());
}
@Test
public void testProperty5() {
String value = "value";
objectUnderTest.setProperty5(value);
assertEquals(value, objectUnderTest.getProperty5());
}
@Test
public void testProperty6() {
String value = "value";
objectUnderTest.setProperty6(value);
assertEquals(value, objectUnderTest.getProperty6());
}
@Test
public void testProperty7() {
String value = "value";
objectUnderTest.setProperty7(value);
assertEquals(value, objectUnderTest.getProperty7());
}
@Test
public void testProperty8() {
String value = "value";
objectUnderTest.setProperty8(value);
assertEquals(value, objectUnderTest.getProperty8());
}
@Test
public void testProperty9() {
String value = "value";
objectUnderTest.setProperty9(value);
assertEquals(value, objectUnderTest.getProperty9());
}
}
|
app.service('UserService', ['$http', function($http) {
return {
getLogged: function(successCallback) {
$http.get('/api/user/logged').then(successCallback);
},
putPin: function(user, successCallback) {
$http.post('/api/user/pin/', user).then(successCallback);
}
};
}]);
|
UPDATE <API key> SET `value` = replace(`value`, '>', '>');
UPDATE <API key> SET `value` = replace(`value`, '<', '<');
|
// Code generated by protoc-gen-gogo.
// source: combos/unsafemarshaler/casttype.proto
// DO NOT EDIT!
/*
Package casttype is a generated protocol buffer package.
It is generated from these files:
combos/unsafemarshaler/casttype.proto
It has these top-level messages:
Castaway
Wilson
*/
package casttype
import proto "github.com/gogo/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/gogo/protobuf/gogoproto"
import <API key> "github.com/gogo/protobuf/test/casttype"
import <API key> "github.com/gogo/protobuf/protoc-gen-gogo/descriptor"
import <API key> "github.com/gogo/protobuf/proto"
import compress_gzip "compress/gzip"
import bytes "bytes"
import io_ioutil "io/ioutil"
import strings "strings"
import reflect "reflect"
import <API key> "github.com/gogo/protobuf/sortkeys"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.<API key> // please upgrade the proto package
type Castaway struct {
Int32Ptr *int32 `protobuf:"varint,1,opt,name=Int32Ptr,casttype=int32" json:"Int32Ptr,omitempty"`
Int32 int32 `protobuf:"varint,2,opt,name=Int32,casttype=int32" json:"Int32"`
MyUint64Ptr *<API key>.MyUint64Type `protobuf:"varint,3,opt,name=MyUint64Ptr,casttype=github.com/gogo/protobuf/test/casttype.MyUint64Type" json:"MyUint64Ptr,omitempty"`
MyUint64 <API key>.MyUint64Type `protobuf:"varint,4,opt,name=MyUint64,casttype=github.com/gogo/protobuf/test/casttype.MyUint64Type" json:"MyUint64"`
MyFloat32Ptr *<API key>.MyFloat32Type `protobuf:"fixed32,5,opt,name=MyFloat32Ptr,casttype=github.com/gogo/protobuf/test/casttype.MyFloat32Type" json:"MyFloat32Ptr,omitempty"`
MyFloat32 <API key>.MyFloat32Type `protobuf:"fixed32,6,opt,name=MyFloat32,casttype=github.com/gogo/protobuf/test/casttype.MyFloat32Type" json:"MyFloat32"`
MyFloat64Ptr *<API key>.MyFloat64Type `protobuf:"fixed64,7,opt,name=MyFloat64Ptr,casttype=github.com/gogo/protobuf/test/casttype.MyFloat64Type" json:"MyFloat64Ptr,omitempty"`
MyFloat64 <API key>.MyFloat64Type `protobuf:"fixed64,8,opt,name=MyFloat64,casttype=github.com/gogo/protobuf/test/casttype.MyFloat64Type" json:"MyFloat64"`
MyBytes <API key>.Bytes `protobuf:"bytes,9,opt,name=MyBytes,casttype=github.com/gogo/protobuf/test/casttype.Bytes" json:"MyBytes,omitempty"`
NormalBytes []byte `protobuf:"bytes,10,opt,name=NormalBytes" json:"NormalBytes,omitempty"`
MyUint64S []<API key>.MyUint64Type `protobuf:"varint,11,rep,name=MyUint64s,casttype=github.com/gogo/protobuf/test/casttype.MyUint64Type" json:"MyUint64s,omitempty"`
MyMap <API key>.MyMapType `protobuf:"bytes,12,rep,name=MyMap,casttype=github.com/gogo/protobuf/test/casttype.MyMapType" json:"MyMap,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
MyCustomMap map[<API key>.MyStringType]<API key>.MyUint64Type `protobuf:"bytes,13,rep,name=MyCustomMap,castkey=github.com/gogo/protobuf/test/casttype.MyStringType,castvalue=github.com/gogo/protobuf/test/casttype.MyUint64Type" json:"MyCustomMap,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
MyNullableMap map[<API key>.MyInt32Type]*Wilson `protobuf:"bytes,14,rep,name=MyNullableMap,castkey=github.com/gogo/protobuf/test/casttype.MyInt32Type" json:"MyNullableMap,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
MyEmbeddedMap map[<API key>.MyInt32Type]Wilson `protobuf:"bytes,15,rep,name=MyEmbeddedMap,castkey=github.com/gogo/protobuf/test/casttype.MyInt32Type" json:"MyEmbeddedMap" protobuf_key:"varint,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
String_ *<API key>.MyStringType `protobuf:"bytes,16,opt,name=String,casttype=github.com/gogo/protobuf/test/casttype.MyStringType" json:"String,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Castaway) Reset() { *m = Castaway{} }
func (*Castaway) ProtoMessage() {}
func (*Castaway) Descriptor() ([]byte, []int) { return <API key>, []int{0} }
type Wilson struct {
Int64 *int64 `protobuf:"varint,1,opt,name=Int64" json:"Int64,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Wilson) Reset() { *m = Wilson{} }
func (*Wilson) ProtoMessage() {}
func (*Wilson) Descriptor() ([]byte, []int) { return <API key>, []int{1} }
func init() {
proto.RegisterType((*Castaway)(nil), "casttype.Castaway")
proto.RegisterType((*Wilson)(nil), "casttype.Wilson")
}
func (this *Castaway) Description() (desc *<API key>.FileDescriptorSet) {
return CasttypeDescription()
}
func (this *Wilson) Description() (desc *<API key>.FileDescriptorSet) {
return CasttypeDescription()
}
func CasttypeDescription() (desc *<API key>.FileDescriptorSet) {
d := &<API key>.FileDescriptorSet{}
var gzipped = []byte{
// 3994 bytes of a gzipped FileDescriptorSet
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xcc, 0x7a, 0x5d, 0x70, 0x1b, 0xd7,
0x75, 0x3f, 0x17, 0x1f, 0x24, 0x70, 0x00, 0x82, 0xcb, 0x4b, 0x5a, 0x86, 0xe8, 0x18, 0xa4, 0x68,
0xcb, 0xa6, 0xed, 0x84, 0xf2, 0x48, 0x94, 0x2c, 0x43, 0x89, 0x3d, 0x00, 0x09, 0x31, 0xd4, 0x10,
0x24, 0xff, 0x4b, 0x32, 0xfe, 0xc8, 0x7f, 0x66, 0xe7, 0x72, 0x71, 0x09, 0xae, 0xb4, 0xd8, 0x45,
0x77, 0x17, 0x92, 0xe1, 0x27, 0x25, 0x6e, 0x9b, 0x49, 0x33, 0xfd, 0xee, 0x4c, 0x13, 0xc7, 0x71,
0xdd, 0xcc, 0xb4, 0x4e, 0xd3, 0xaf, 0xa4, 0x6d, 0xd2, 0x4e, 0x9e, 0xf2, 0x92, 0xd6, 0x4f, 0x9d,
0xe4, 0xad, 0x0f, 0x1d, 0x39, 0x62, 0x3d, 0x53, 0xa7, 0x75, 0x5b, 0xb7, 0xf5, 0x4c, 0x33, 0xf2,
0x4b, 0xe7, 0x7e, 0x2d, 0x16, 0x1f, 0xd4, 0x82, 0xca, 0x24, 0xe9, 0x13, 0x79, 0xcf, 0x3d, 0xbf,
0xdf, 0x9e, 0x7b, 0xee, 0xb9, 0xe7, 0x9c, 0xbd, 0x0b, 0xf8, 0xcc, 0x12, 0xcc, 0xd5, 0x1d, 0xa7,
0x6e, 0x91, 0x33, 0x4d, 0xd7, 0xf1, 0x9d, 0xbd, 0xd6, 0xfe, 0x99, 0x1a, 0xf1, 0x0c, 0xd7, 0x6c,
0xfa, 0x8e, 0xbb, 0xc8, 0x64, 0x68, 0x82, 0x6b, 0x2c, 0x4a, 0x8d, 0xf9, 0x2a, 0x4c, 0x5e, 0x36,
0x2d, 0xb2, 0x12, 0x28, 0x6e, 0x13, 0x1f, 0x5d, 0x84, 0xc4, 0xbe, 0x69, 0x91, 0xbc, 0x32, 0x17,
0x5f, 0xc8, 0x9c, 0x7d, 0x78, 0xb1, 0x07, 0xb4, 0xd8, 0x8d, 0xd8, 0xa2, 0x62, 0x8d, 0x21, 0xe6,
0xdf, 0x49, 0xc0, 0xd4, 0x80, 0x59, 0x84, 0x20, 0x61, 0xe3, 0x06, 0x65, 0x54, 0x16, 0xd2, 0x1a,
0xfb, 0x1f, 0xe5, 0x61, 0xac, 0x89, 0x8d, 0x6b, 0xb8, 0x4e, 0xf2, 0x31, 0x26, 0x96, 0x43, 0x54,
0x00, 0xa8, 0x91, 0x26, 0xb1, 0x6b, 0xc4, 0x36, 0xda, 0xf9, 0xf8, 0x5c, 0x7c, 0x21, 0xad, 0x85,
0x24, 0xe8, 0x09, 0x98, 0x6c, 0xb6, 0xf6, 0x2c, 0xd3, 0xd0, 0x43, 0x6a, 0x30, 0x17, 0x5f, 0x48,
0x6a, 0x2a, 0x9f, 0x58, 0xe9, 0x28, 0x3f, 0x0a, 0x13, 0x37, 0x08, 0xbe, 0x16, 0x56, 0xcd, 0x30,
0xd5, 0x1c, 0x15, 0x87, 0x14, 0x97, 0x21, 0xdb, 0x20, 0x9e, 0x87, 0xeb, 0x44, 0xf7, 0xdb, 0x4d,
0x92, 0x4f, 0xb0, 0xd5, 0xcf, 0xf5, 0xad, 0xbe, 0x77, 0xe5, 0x19, 0x81, 0xda, 0x69, 0x37, 0x09,
0x2a, 0x41, 0x9a, 0xd8, 0xad, 0x06, 0x67, 0x48, 0x1e, 0xe1, 0xbf, 0x8a, 0xdd, 0x6a, 0xf4, 0xb2,
0xa4, 0x28, 0x4c, 0x50, 0x8c, 0x79, 0xc4, 0xbd, 0x6e, 0x1a, 0x24, 0x3f, 0xca, 0x08, 0x1e, 0xed,
0x23, 0xd8, 0xe6, 0xf3, 0xbd, 0x1c, 0x12, 0x87, 0x96, 0x21, 0x4d, 0x5e, 0xf2, 0x89, 0xed, 0x99,
0x8e, 0x9d, 0x1f, 0x63, 0x24, 0xa7, 0x07, 0xec, 0x22, 0xb1, 0x6a, 0xbd, 0x14, 0x1d, 0x1c, 0xba,
0x00, 0x63, 0x4e, 0xd3, 0x37, 0x1d, 0xdb, 0xcb, 0xa7, 0xe6, 0x94, 0x85, 0xcc, 0xd9, 0x8f, 0x0c,
0x0c, 0x84, 0x4d, 0xae, 0xa3, 0x49, 0x65, 0xb4, 0x06, 0xaa, 0xe7, 0xb4, 0x5c, 0x83, 0xe8, 0x86,
0x53, 0x23, 0xba, 0x69, 0xef, 0x3b, 0xf9, 0x34, 0x23, 0x98, 0xed, 0x5f, 0x08, 0x53, 0x5c, 0x76,
0x6a, 0x64, 0xcd, 0xde, 0x77, 0xb4, 0x9c, 0xd7, 0x35, 0x46, 0x27, 0x60, 0xd4, 0x6b, 0xdb, 0x3e,
0x7e, 0x29, 0x9f, 0x65, 0x11, 0x22, 0x46, 0xf3, 0xff, 0x93, 0x84, 0x89, 0x61, 0x42, 0xec, 0x12,
0x24, 0xf7, 0xe9, 0x2a, 0xf3, 0xb1, 0xe3, 0xf8, 0x80, 0x63, 0xba, 0x9d, 0x38, 0x7a, 0x8f, 0x4e,
0x2c, 0x41, 0xc6, 0x26, 0x9e, 0x4f, 0x6a, 0x3c, 0x22, 0xe2, 0x43, 0xc6, 0x14, 0x70, 0x50, 0x7f,
0x48, 0x25, 0xee, 0x29, 0xa4, 0x9e, 0x87, 0x89, 0xc0, 0x24, 0xdd, 0xc5, 0x76, 0x5d, 0xc6, 0xe6,
0x99, 0x28, 0x4b, 0x16, 0x2b, 0x12, 0xa7, 0x51, 0x98, 0x96, 0x23, 0x5d, 0x63, 0xb4, 0x02, 0xe0,
0xd8, 0xc4, 0xd9, 0xd7, 0x6b, 0xc4, 0xb0, 0xf2, 0xa9, 0x23, 0xbc, 0xb4, 0x49, 0x55, 0xfa, 0xbc,
0xe4, 0x70, 0xa9, 0x61, 0xa1, 0xa7, 0x3b, 0xa1, 0x36, 0x76, 0x44, 0xa4, 0x54, 0xf9, 0x21, 0xeb,
0x8b, 0xb6, 0x5d, 0xc8, 0xb9, 0x84, 0xc6, 0x3d, 0xa9, 0x89, 0x95, 0xa5, 0x99, 0x11, 0x8b, 0x91,
0x2b, 0xd3, 0x04, 0x8c, 0x2f, 0x6c, 0xdc, 0x0d, 0x0f, 0xd1, 0x43, 0x10, 0x08, 0x74, 0x16, 0x56,
0xc0, 0xb2, 0x50, 0x56, 0x0a, 0x37, 0x70, 0x83, 0xcc, 0x5c, 0x84, 0x5c, 0xb7, 0x7b, 0xd0, 0x34,
0x24, 0x3d, 0x1f, 0xbb, 0x3e, 0x8b, 0xc2, 0xa4, 0xc6, 0x07, 0x48, 0x85, 0x38, 0xb1, 0x6b, 0x2c,
0xcb, 0x25, 0x35, 0xfa, 0xef, 0xcc, 0x53, 0x30, 0xde, 0xf5, 0xf8, 0x61, 0x81, 0xf3, 0x5f, 0x1c,
0x85, 0xe9, 0x41, 0x31, 0x37, 0x30, 0xfc, 0x4f, 0xc0, 0xa8, 0xdd, 0x6a, 0xec, 0x11, 0x37, 0x1f,
0x67, 0x0c, 0x62, 0x84, 0x4a, 0x90, 0xb4, 0xf0, 0x1e, 0xb1, 0xf2, 0x89, 0x39, 0x65, 0x21, 0x77,
0xf6, 0x89, 0xa1, 0xa2, 0x7a, 0x71, 0x9d, 0x42, 0x34, 0x8e, 0x44, 0xcf, 0x40, 0x42, 0xa4, 0x38,
0xca, 0xf0, 0xf8, 0x70, 0x0c, 0x34, 0x16, 0x35, 0x86, 0x43, 0x0f, 0x40, 0x9a, 0xfe, 0xe5, 0xbe,
0x1d, 0x65, 0x36, 0xa7, 0xa8, 0x80, 0xfa, 0x15, 0xcd, 0x40, 0x8a, 0x85, 0x59, 0x8d, 0xc8, 0xd2,
0x10, 0x8c, 0xe9, 0xc6, 0xd4, 0xc8, 0x3e, 0x6e, 0x59, 0xbe, 0x7e, 0x1d, 0x5b, 0x2d, 0xc2, 0x02,
0x26, 0xad, 0x65, 0x85, 0xf0, 0x53, 0x54, 0x86, 0x66, 0x21, 0xc3, 0xa3, 0xd2, 0xb4, 0x6b, 0xe4,
0x25, 0x96, 0x7d, 0x92, 0x1a, 0x0f, 0xd4, 0x35, 0x2a, 0xa1, 0x8f, 0xbf, 0xea, 0x39, 0xb6, 0xdc,
0x5a, 0xf6, 0x08, 0x2a, 0x60, 0x8f, 0x7f, 0xaa, 0x37, 0xf1, 0x3d, 0x38, 0x78, 0x79, 0xbd, 0xb1,
0x38, 0xff, 0xed, 0x18, 0x24, 0xd8, 0x79, 0x9b, 0x80, 0xcc, 0xce, 0x0b, 0x5b, 0x15, 0x7d, 0x65,
0x73, 0xb7, 0xbc, 0x5e, 0x51, 0x15, 0x94, 0x03, 0x60, 0x82, 0xcb, 0xeb, 0x9b, 0xa5, 0x1d, 0x35,
0x16, 0x8c, 0xd7, 0x36, 0x76, 0x2e, 0x2c, 0xa9, 0xf1, 0x00, 0xb0, 0xcb, 0x05, 0x89, 0xb0, 0xc2,
0xb9, 0xb3, 0x6a, 0x12, 0xa9, 0x90, 0xe5, 0x04, 0x6b, 0xcf, 0x57, 0x56, 0x2e, 0x2c, 0xa9, 0xa3,
0xdd, 0x92, 0x73, 0x67, 0xd5, 0x31, 0x34, 0x0e, 0x69, 0x26, 0x29, 0x6f, 0x6e, 0xae, 0xab, 0xa9,
0x80, 0x73, 0x7b, 0x47, 0x5b, 0xdb, 0x58, 0x55, 0xd3, 0x01, 0xe7, 0xaa, 0xb6, 0xb9, 0xbb, 0xa5,
0x42, 0xc0, 0x50, 0xad, 0x6c, 0x6f, 0x97, 0x56, 0x2b, 0x6a, 0x26, 0xd0, 0x28, 0xbf, 0xb0, 0x53,
0xd9, 0x56, 0xb3, 0x5d, 0x66, 0x9d, 0x3b, 0xab, 0x8e, 0x07, 0x8f, 0xa8, 0x6c, 0xec, 0x56, 0xd5,
0x1c, 0x9a, 0x84, 0x71, 0xfe, 0x08, 0x69, 0xc4, 0x44, 0x8f, 0xe8, 0xc2, 0x92, 0xaa, 0x76, 0x0c,
0xe1, 0x2c, 0x93, 0x5d, 0x82, 0x0b, 0x4b, 0x2a, 0x9a, 0x5f, 0x86, 0x24, 0x8b, 0x2e, 0x84, 0x20,
0xb7, 0x5e, 0x2a, 0x57, 0xd6, 0xf5, 0xcd, 0xad, 0x9d, 0xb5, 0xcd, 0x8d, 0xd2, 0xba, 0xaa, 0x74,
0x64, 0x5a, 0xe5, 0xff, 0xed, 0xae, 0x69, 0x95, 0x15, 0x35, 0x16, 0x96, 0x6d, 0x55, 0x4a, 0x3b,
0x95, 0x15, 0x35, 0x3e, 0x6f, 0xc0, 0xf4, 0xa0, 0x3c, 0x33, 0xf0, 0x64, 0x84, 0xb6, 0x38, 0x76,
0xc4, 0x16, 0x33, 0xae, 0xbe, 0x2d, 0xfe, 0xaa, 0x02, 0x53, 0x03, 0x72, 0xed, 0xc0, 0x87, 0x3c,
0x0b, 0x49, 0x1e, 0xa2, 0xbc, 0xfa, 0x3c, 0x36, 0x30, 0x69, 0xb3, 0x80, 0xed, 0xab, 0x40, 0x0c,
0x17, 0xae, 0xc0, 0xf1, 0x23, 0x2a, 0x30, 0xa5, 0xe8, 0x33, 0xf2, 0x15, 0x05, 0xf2, 0x47, 0x71,
0x47, 0x24, 0x8a, 0x58, 0x57, 0xa2, 0xb8, 0xd4, 0x6b, 0xc0, 0xa9, 0xa3, 0xd7, 0xd0, 0x67, 0xc5,
0x9b, 0x0a, 0x9c, 0x18, 0xdc, 0xa8, 0x0c, 0xb4, 0xe1, 0x19, 0x18, 0x6d, 0x10, 0xff, 0xc0, 0x91,
0xc5, 0xfa, 0x91, 0x01, 0x25, 0x80, 0x4e, 0xf7, 0xfa, 0x4a, 0xa0, 0xc2, 0x35, 0x24, 0x7e, 0x54,
0xb7, 0xc1, 0xad, 0xe9, 0xb3, 0xf4, 0xf3, 0x31, 0xb8, 0x6f, 0x20, 0xf9, 0x40, 0x43, 0x1f, 0x04,
0x30, 0xed, 0x66, 0xcb, 0xe7, 0x05, 0x99, 0xe7, 0xa7, 0x34, 0x93, 0xb0, 0xb3, 0x4f, 0x73, 0x4f,
0xcb, 0x0f, 0xe6, 0xe3, 0x6c, 0x1e, 0xb8, 0x88, 0x29, 0x5c, 0xec, 0x18, 0x9a, 0x60, 0x86, 0x16,
0x8e, 0x58, 0x69, 0x5f, 0xad, 0x7b, 0x12, 0x54, 0xc3, 0x32, 0x89, 0xed, 0xeb, 0x9e, 0xef, 0x12,
0xdc, 0x30, 0xed, 0x3a, 0x4b, 0xc0, 0xa9, 0x62, 0x72, 0x1f, 0x5b, 0x1e, 0xd1, 0x26, 0xf8, 0xf4,
0xb6, 0x9c, 0xa5, 0x08, 0x56, 0x65, 0xdc, 0x10, 0x62, 0xb4, 0x0b, 0xc1, 0xa7, 0x03, 0xc4, 0xfc,
0x17, 0xc6, 0x20, 0x13, 0x6a, 0xeb, 0xd0, 0x29, 0xc8, 0x5e, 0xc5, 0xd7, 0xb1, 0x2e, 0x5b, 0x75,
0xee, 0x89, 0x0c, 0x95, 0x6d, 0x89, 0x76, 0xfd, 0x49, 0x98, 0x66, 0x2a, 0x4e, 0xcb, 0x27, 0xae,
0x6e, 0x58, 0xd8, 0xf3, 0x98, 0xd3, 0x52, 0x4c, 0x15, 0xd1, 0xb9, 0x4d, 0x3a, 0xb5, 0x2c, 0x67,
0xd0, 0x79, 0x98, 0x62, 0x88, 0x46, 0xcb, 0xf2, 0xcd, 0xa6, 0x45, 0x74, 0xfa, 0xf2, 0xe0, 0xb1,
0x44, 0x1c, 0x58, 0x36, 0x49, 0x35, 0xaa, 0x42, 0x81, 0x5a, 0xe4, 0xa1, 0x55, 0x78, 0x90, 0xc1,
0xea, 0xc4, 0x26, 0x2e, 0xf6, 0x89, 0x4e, 0x7e, 0xa1, 0x85, 0x2d, 0x4f, 0xc7, 0x76, 0x4d, 0x3f,
0xc0, 0xde, 0x41, 0x7e, 0x3a, 0x4c, 0x70, 0x92, 0xea, 0xae, 0x0a, 0xd5, 0x0a, 0xd3, 0x2c, 0xd9,
0xb5, 0x4f, 0x62, 0xef, 0x00, 0x15, 0xe1, 0x04, 0x23, 0xf2, 0x7c, 0xd7, 0xb4, 0xeb, 0xba, 0x71,
0x40, 0x8c, 0x6b, 0x7a, 0xcb, 0xdf, 0xbf, 0x98, 0x7f, 0x20, 0xcc, 0xc0, 0x8c, 0xdc, 0x66, 0x3a,
0xcb, 0x54, 0x65, 0xd7, 0xdf, 0xbf, 0x88, 0xb6, 0x21, 0x4b, 0xf7, 0xa3, 0x61, 0xbe, 0x4c, 0xf4,
0x7d, 0xc7, 0x65, 0xc5, 0x25, 0x37, 0xe0, 0x70, 0x87, 0x9c, 0xb8, 0xb8, 0x29, 0x00, 0x55, 0xa7,
0x46, 0x8a, 0xc9, 0xed, 0xad, 0x4a, 0x65, 0x45, 0xcb, 0x48, 0x96, 0xcb, 0x8e, 0x4b, 0x63, 0xaa,
0xee, 0x04, 0x3e, 0xce, 0xf0, 0x98, 0xaa, 0x3b, 0xd2, 0xc3, 0xe7, 0x61, 0xca, 0x30, 0xf8, 0xb2,
0x4d, 0x43, 0x17, 0x5d, 0xbe, 0x97, 0x57, 0xbb, 0xfc, 0x65, 0x18, 0xab, 0x5c, 0x41, 0x84, 0xb9,
0x87, 0x9e, 0x86, 0xfb, 0x3a, 0xfe, 0x0a, 0x03, 0x27, 0xfb, 0x56, 0xd9, 0x0b, 0x3d, 0x0f, 0x53,
0xcd, 0x76, 0x3f, 0x10, 0x75, 0x3d, 0xb1, 0xd9, 0xee, 0x85, 0x9d, 0x66, 0x6f, 0x6e, 0x2e, 0x31,
0xb0, 0x4f, 0x6a, 0xf9, 0xfb, 0xc3, 0xda, 0xa1, 0x09, 0x74, 0x06, 0x54, 0xc3, 0xd0, 0x89, 0x8d,
0xf7, 0x2c, 0xa2, 0x63, 0x97, 0xd8, 0xd8, 0xcb, 0xcf, 0x86, 0x95, 0x73, 0x86, 0x51, 0x61, 0xb3,
0x25, 0x36, 0x89, 0x1e, 0x87, 0x49, 0x67, 0xef, 0xaa, 0xc1, 0x83, 0x4b, 0x6f, 0xba, 0x64, 0xdf,
0x7c, 0x29, 0xff, 0x30, 0x73, 0xd3, 0x04, 0x9d, 0x60, 0xa1, 0xb5, 0xc5, 0xc4, 0xe8, 0x31, 0x50,
0x0d, 0xef, 0x00, 0xbb, 0x4d, 0x56, 0xdd, 0xbd, 0x26, 0x36, 0x48, 0xfe, 0x34, 0x57, 0xe5, 0xf2,
0x0d, 0x29, 0x46, 0xcf, 0xc3, 0x74, 0xcb, 0x36, 0x6d, 0x9f, 0xb8, 0x4d, 0x97, 0xd0, 0x26, 0x9d,
0x9f, 0xb4, 0xfc, 0x3f, 0x8f, 0x1d, 0xd1, 0x66, 0xef, 0x86, 0xb5, 0xf9, 0xee, 0x6a, 0x53, 0xad,
0x7e, 0xe1, 0x7c, 0x11, 0xb2, 0xe1, 0x4d, 0x47, 0x69, 0xe0, 0xdb, 0xae, 0x2a, 0xb4, 0x86, 0x2e,
0x6f, 0xae, 0xd0, 0xea, 0xf7, 0x62, 0x45, 0x8d, 0xd1, 0x2a, 0xbc, 0xbe, 0xb6, 0x53, 0xd1, 0xb5,
0xdd, 0x8d, 0x9d, 0xb5, 0x6a, 0x45, 0x8d, 0x3f, 0x9e, 0x4e, 0xbd, 0x3b, 0xa6, 0xde, 0xbc, 0x79,
0xf3, 0x66, 0x6c, 0xfe, 0x7b, 0x31, 0xc8, 0x75, 0x77, 0xbe, 0xe8, 0xe3, 0x70, 0xbf, 0x7c, 0x4d,
0xf5, 0x88, 0xaf, 0xdf, 0x30, 0x5d, 0x16, 0x87, 0x0d, 0xcc, 0x7b, 0xc7, 0xc0, 0x85, 0xd3, 0x42,
0x6b, 0x9b, 0xf8, 0xcf, 0x99, 0x2e, 0x8d, 0xb2, 0x06, 0xf6, 0xd1, 0x3a, 0xcc, 0xda, 0x8e, 0xee,
0xf9, 0xd8, 0xae, 0x61, 0xb7, 0xa6, 0x77, 0x2e, 0x08, 0x74, 0x6c, 0x18, 0xc4, 0xf3, 0x1c, 0x5e,
0x02, 0x02, 0x96, 0x8f, 0xd8, 0xce, 0xb6, 0x50, 0xee, 0xe4, 0xc6, 0x92, 0x50, 0xed, 0xd9, 0xee,
0xf8, 0x51, 0xdb, 0xfd, 0x00, 0xa4, 0x1b, 0xb8, 0xa9, 0x13, 0xdb, 0x77, 0xdb, 0xac, 0x5f, 0x4b,
0x69, 0xa9, 0x06, 0x6e, 0x56, 0xe8, 0xf8, 0xa7, 0xb7, 0x07, 0x61, 0x3f, 0xfe, 0x63, 0x1c, 0xb2,
0xe1, 0x9e, 0x8d, 0xb6, 0xc0, 0x06, 0xcb, 0xcf, 0x0a, 0x3b, 0xbe, 0x0f, 0xdd, 0xb5, 0xc3, 0x5b,
0x5c, 0xa6, 0x89, 0xbb, 0x38, 0xca, 0x3b, 0x29, 0x8d, 0x23, 0x69, 0xd1, 0xa4, 0x07, 0x96, 0xf0,
0xfe, 0x3c, 0xa5, 0x89, 0x11, 0x5a, 0x85, 0xd1, 0xab, 0x1e, 0xe3, 0x1e, 0x65, 0xdc, 0x0f, 0xdf,
0x9d, 0xfb, 0xca, 0x36, 0x23, 0x4f, 0x5f, 0xd9, 0xd6, 0x37, 0x36, 0xb5, 0x6a, 0x69, 0x5d, 0x13,
0x70, 0x74, 0x12, 0x12, 0x16, 0x7e, 0xb9, 0xdd, 0x9d, 0xe2, 0x99, 0x68, 0x58, 0xc7, 0x9f, 0x84,
0xc4, 0x0d, 0x82, 0xaf, 0x75, 0x27, 0x56, 0x26, 0xfa, 0x29, 0x86, 0xfe, 0x19, 0x48, 0x32, 0x7f,
0x21, 0x00, 0xe1, 0x31, 0x75, 0x04, 0xa5, 0x20, 0xb1, 0xbc, 0xa9, 0xd1, 0xf0, 0x57, 0x21, 0xcb,
0xa5, 0xfa, 0xd6, 0x5a, 0x65, 0xb9, 0xa2, 0xc6, 0xe6, 0xcf, 0xc3, 0x28, 0x77, 0x02, 0x3d, 0x1a,
0x81, 0x1b, 0xd4, 0x11, 0x31, 0x14, 0x1c, 0x8a, 0x9c, 0xdd, 0xad, 0x96, 0x2b, 0x9a, 0x1a, 0x0b,
0x6f, 0xaf, 0x07, 0xd9, 0x70, 0xbb, 0xf6, 0xb3, 0x89, 0xa9, 0xef, 0x28, 0x90, 0x09, 0xb5, 0x5f,
0xb4, 0xf0, 0x63, 0xcb, 0x72, 0x6e, 0xe8, 0xd8, 0x32, 0xb1, 0x27, 0x82, 0x02, 0x98, 0xa8, 0x44,
0x25, 0xc3, 0x6e, 0xda, 0xcf, 0xc4, 0xf8, 0xd7, 0x15, 0x50, 0x7b, 0x5b, 0xb7, 0x1e, 0x03, 0x95,
0x9f, 0xab, 0x81, 0xaf, 0x29, 0x90, 0xeb, 0xee, 0xd7, 0x7a, 0xcc, 0x3b, 0xf5, 0x73, 0x35, 0xef,
0xcb, 0x0a, 0x8c, 0x77, 0x75, 0x69, 0xff, 0xa7, 0xac, 0x7b, 0x35, 0x0e, 0x53, 0x03, 0x70, 0xa8,
0x24, 0xda, 0x59, 0xde, 0x61, 0x7f, 0x6c, 0x98, 0x67, 0x2d, 0xd2, 0x6a, 0xb9, 0x85, 0x5d, 0x5f,
0x74, 0xbf, 0x8f, 0x81, 0x6a, 0xd6, 0x88, 0xed, 0x9b, 0xfb, 0x26, 0x71, 0xc5, 0x2b, 0x38, 0xef,
0x71, 0x27, 0x3a, 0x72, 0xfe, 0x16, 0xfe, 0x51, 0x40, 0x4d, 0xc7, 0x33, 0x7d, 0xf3, 0x3a, 0xd1,
0x4d, 0x5b, 0xbe, 0xaf, 0xd3, 0x9e, 0x37, 0xa1, 0xa9, 0x72, 0x66, 0xcd, 0xf6, 0x03, 0x6d, 0x9b,
0xd4, 0x71, 0x8f, 0x36, 0xcd, 0x7d, 0x71, 0x4d, 0x95, 0x33, 0x81, 0xf6, 0x29, 0xc8, 0xd6, 0x9c,
0x16, 0x6d, 0x1f, 0xb8, 0x1e, 0x4d, 0xb5, 0x8a, 0x96, 0xe1, 0xb2, 0x40, 0x45, 0xf4, 0x77, 0x9d,
0x8b, 0x82, 0xac, 0x96, 0xe1, 0x32, 0xae, 0xf2, 0x28, 0x4c, 0xe0, 0x7a, 0xdd, 0xa5, 0xe4, 0x92,
0x88, 0x37, 0xad, 0xb9, 0x40, 0xcc, 0x14, 0x67, 0xae, 0x40, 0x4a, 0xfa, 0x81, 0x56, 0x33, 0xea,
0x09, 0xbd, 0xc9, 0xaf, 0x6b, 0x62, 0x0b, 0x69, 0x2d, 0x65, 0xcb, 0xc9, 0x53, 0x90, 0x35, 0x3d,
0xbd, 0x73, 0x6f, 0x18, 0x9b, 0x8b, 0x2d, 0xa4, 0xb4, 0x8c, 0xe9, 0x05, 0x17, 0x45, 0xf3, 0x6f,
0xc6, 0x20, 0xd7, 0x7d, 0xef, 0x89, 0x56, 0x20, 0x65, 0x39, 0x06, 0x66, 0x81, 0xc0, 0x2f, 0xdd,
0x17, 0x22, 0xae, 0x4a, 0x17, 0xd7, 0x85, 0xbe, 0x16, 0x20, 0x67, 0xfe, 0x5e, 0x81, 0x94, 0x14,
0xa3, 0x13, 0x90, 0x68, 0x62, 0xff, 0x80, 0xd1, 0x25, 0xcb, 0x31, 0x55, 0xd1, 0xd8, 0x98, 0xca,
0xbd, 0x26, 0xb6, 0x59, 0x08, 0x08, 0x39, 0x1d, 0xd3, 0x7d, 0xb5, 0x08, 0xae, 0xb1, 0x76, 0xd8,
0x69, 0x34, 0x88, 0xed, 0x7b, 0x72, 0x5f, 0x85, 0x7c, 0x59, 0x88, 0xd1, 0x13, 0x30, 0xe9, 0xbb,
0xd8, 0xb4, 0xba, 0x74, 0x13, 0x4c, 0x57, 0x95, 0x13, 0x81, 0x72, 0x11, 0x4e, 0x4a, 0xde, 0x1a,
0xf1, 0xb1, 0x71, 0x40, 0x6a, 0x1d, 0xd0, 0x28, 0xbb, 0x54, 0xbb, 0x5f, 0x28, 0xac, 0x88, 0x79,
0x89, 0x9d, 0xff, 0x81, 0x02, 0x93, 0xb2, 0x81, 0xaf, 0x05, 0xce, 0xaa, 0x02, 0x60, 0xdb, 0x76,
0xfc, 0xb0, 0xbb, 0xfa, 0x43, 0xb9, 0x0f, 0xb7, 0x58, 0x0a, 0x40, 0x5a, 0x88, 0x60, 0xa6, 0x01,
0xd0, 0x99, 0x39, 0xd2, 0x6d, 0xb3, 0x90, 0x11, 0x97, 0xda, 0xec, 0xcb, 0x08, 0x7f, 0xeb, 0x03,
0x2e, 0xa2, 0x9d, 0x3e, 0x9a, 0x86, 0xe4, 0x1e, 0xa9, 0x9b, 0xb6, 0xb8, 0x6a, 0xe3, 0x03, 0x79,
0x81, 0x97, 0x08, 0x2e, 0xf0, 0xca, 0x9f, 0x86, 0x29, 0xc3, 0x69, 0xf4, 0x9a, 0x5b, 0x56, 0x7b,
0xde, 0x3c, 0xbd, 0x4f, 0x2a, 0x2f, 0x42, 0xa7, 0x3b, 0x7b, 0x43, 0x51, 0xbe, 0x1a, 0x8b, 0xaf,
0x6e, 0x95, 0xbf, 0x1e, 0x9b, 0x59, 0xe5, 0xd0, 0x2d, 0xb9, 0x52, 0x8d, 0xec, 0x5b, 0xc4, 0xa0,
0xd6, 0xc3, 0x1b, 0x8f, 0xc0, 0xc7, 0xea, 0xa6, 0x7f, 0xd0, 0xda, 0x5b, 0x34, 0x9c, 0xc6, 0x99,
0xba, 0x53, 0x77, 0x3a, 0x1f, 0x83, 0xe8, 0x88, 0x0d, 0xd8, 0x7f, 0xe2, 0x83, 0x50, 0x3a, 0x90,
0xce, 0x44, 0x7e, 0x3d, 0x2a, 0x6e, 0xc0, 0x94, 0x50, 0xd6, 0xd9, 0x8d, 0x34, 0xef, 0xc3, 0xd1,
0x5d, 0x6f, 0x25, 0xf2, 0xdf, 0x7c, 0x87, 0x55, 0x3a, 0x6d, 0x52, 0x40, 0xe9, 0x1c, 0xef, 0xd4,
0x8b, 0x1a, 0xdc, 0xd7, 0xc5, 0xc7, 0x8f, 0x26, 0x71, 0x23, 0x18, 0xbf, 0x27, 0x18, 0xa7, 0x42,
0x8c, 0xdb, 0x02, 0x5a, 0x5c, 0x86, 0xf1, 0xe3, 0x70, 0xfd, 0xad, 0xe0, 0xca, 0x92, 0x30, 0xc9,
0x2a, 0x4c, 0x30, 0x12, 0xa3, 0xe5, 0xf9, 0x4e, 0x83, 0xe5, 0xbd, 0xbb, 0xd3, 0xfc, 0xdd, 0x3b,
0xfc, 0xac, 0xe4, 0x28, 0x6c, 0x39, 0x40, 0x15, 0x8b, 0xc0, 0x2e, 0xe1, 0x6b, 0xc4, 0xb0, 0x22,
0x18, 0xde, 0x12, 0x86, 0x04, 0xfa, 0xc5, 0x4f, 0xc1, 0x34, 0xfd, 0x9f, 0xa5, 0xa5, 0xb0, 0x25,
0xd1, 0x77, 0x30, 0xf9, 0x1f, 0xbc, 0xc2, 0x8f, 0xe3, 0x54, 0x40, 0x10, 0xb2, 0x29, 0xb4, 0x8b,
0x75, 0xe2, 0xfb, 0xc4, 0xf5, 0x74, 0x6c, 0x0d, 0x32, 0x2f, 0xf4, 0x06, 0x9b, 0xff, 0xd2, 0x7b,
0xdd, 0xbb, 0xb8, 0xca, 0x91, 0x25, 0xcb, 0x2a, 0xee, 0xc2, 0xfd, 0x03, 0xa2, 0x62, 0x08, 0xce,
0x57, 0x05, 0xe7, 0x74, 0x5f, 0x64, 0x50, 0xda, 0x2d, 0x90, 0xf2, 0x60, 0x2f, 0x87, 0xe0, 0xfc,
0xb2, 0xe0, 0x44, 0x02, 0x2b, 0xb7, 0x94, 0x32, 0x5e, 0x81, 0xc9, 0xeb, 0xc4, 0xdd, 0x73, 0x3c,
0x71, 0x71, 0x30, 0x04, 0xdd, 0x6b, 0x82, 0x6e, 0x42, 0x00, 0xd9, 0x35, 0x02, 0xe5, 0x7a, 0x1a,
0x52, 0xfb, 0xd8, 0x20, 0x43, 0x50, 0x7c, 0x45, 0x50, 0x8c, 0x51, 0x7d, 0x0a, 0x2d, 0x41, 0xb6,
0xee, 0x88, 0xca, 0x14, 0x0d, 0x7f, 0x5d, 0xc0, 0x33, 0x12, 0x23, 0x28, 0x9a, 0x4e, 0xb3, 0x65,
0xd1, 0xb2, 0x15, 0x4d, 0xf1, 0x7b, 0x92, 0x42, 0x62, 0x04, 0xc5, 0x31, 0xdc, 0xfa, 0x86, 0xa4,
0xf0, 0x42, 0xfe, 0x7c, 0x16, 0x32, 0x8e, 0x6d, 0xb5, 0x1d, 0x7b, 0x18, 0x23, 0x7e, 0x5f, 0x30,
0x80, 0x80, 0x50, 0x82, 0x4b, 0x90, 0x1e, 0x76, 0x23, 0xfe, 0xe0, 0x3d, 0x79, 0x3c, 0xe4, 0x0e,
0xac, 0xc2, 0x84, 0x4c, 0x50, 0xa6, 0x63, 0x0f, 0x41, 0xf1, 0x87, 0x82, 0x22, 0x17, 0x82, 0x89,
0x65, 0xf8, 0xc4, 0xf3, 0xeb, 0x64, 0x18, 0x92, 0x37, 0xe5, 0x32, 0x04, 0x44, 0xb8, 0x72, 0x8f,
0xd8, 0xc6, 0xc1, 0x70, 0x0c, 0x5f, 0x93, 0xae, 0x94, 0x18, 0x4a, 0xb1, 0x0c, 0xe3, 0x0d, 0xec,
0x7a, 0x07, 0xd8, 0x1a, 0x6a, 0x3b, 0xfe, 0x48, 0x70, 0x64, 0x03, 0x90, 0xf0, 0x48, 0xcb, 0x3e,
0x0e, 0xcd, 0xd7, 0xa5, 0x47, 0x42, 0x30, 0x71, 0xf4, 0x3c, 0x9f, 0xdd, 0xcd, 0x1c, 0x87, 0xed,
0x8f, 0xe5, 0xd1, 0xe3, 0xd8, 0x6a, 0x98, 0xf1, 0x12, 0xa4, 0x3d, 0xf3, 0xe5, 0xa1, 0x68, 0xfe,
0x44, 0xee, 0x34, 0x03, 0x50, 0xf0, 0x0b, 0x70, 0x72, 0x60, 0x99, 0x18, 0x82, 0xec, 0x4f, 0x05,
0xd9, 0x89, 0x01, 0xa5, 0x42, 0xa4, 0x84, 0xe3, 0x52, 0xfe, 0x99, 0x4c, 0x09, 0xa4, 0x87, 0x6b,
0x8b, 0x76, 0xf6, 0x1e, 0xde, 0x3f, 0x9e, 0xd7, 0xfe, 0x5c, 0x7a, 0x8d, 0x63, 0xbb, 0xbc, 0xb6,
0x03, 0x27, 0x04, 0xe3, 0xf1, 0xf6, 0xf5, 0x1b, 0x32, 0xb1, 0x72, 0xf4, 0x6e, 0xf7, 0xee, 0x7e,
0x1a, 0x66, 0x02, 0x77, 0xca, 0xa6, 0xd4, 0xd3, 0x1b, 0xb8, 0x39, 0x04, 0xf3, 0x37, 0x05, 0xb3,
0xcc, 0xf8, 0x41, 0x57, 0xeb, 0x55, 0x71, 0x93, 0x92, 0x3f, 0x0f, 0x79, 0x49, 0xde, 0xb2, 0x5d,
0x62, 0x38, 0x75, 0xdb, 0x7c, 0x99, 0xd4, 0x86, 0xa0, 0xfe, 0x8b, 0x9e, 0xad, 0xda, 0x0d, 0xc1,
0x29, 0xf3, 0x1a, 0xa8, 0x41, 0xaf, 0xa2, 0x9b, 0x8d, 0xa6, 0xe3, 0xfa, 0x11, 0x8c, 0x7f, 0x29,
0x77, 0x2a, 0xc0, 0xad, 0x31, 0x58, 0xb1, 0x02, 0x39, 0x36, 0x1c, 0x36, 0x24, 0xff, 0x4a, 0x10,
0x8d, 0x77, 0x50, 0x22, 0x71, 0x18, 0x4e, 0xa3, 0x89, 0xdd, 0x61, 0xf2, 0xdf, 0xb7, 0x64, 0xe2,
0x10, 0x10, 0x91, 0x38, 0xfc, 0x76, 0x93, 0xd0, 0x6a, 0x3f, 0x04, 0xc3, 0xb7, 0x65, 0xe2, 0x90,
0x18, 0x41, 0x21, 0x1b, 0x86, 0x21, 0x28, 0xfe, 0x5a, 0x52, 0x48, 0x0c, 0x3f, 0x03, 0x13, 0x3d,
0xfd, 0x00, 0x8a, 0xfa, 0xfc, 0x9e, 0xff, 0xcc, 0x07, 0x22, 0x73, 0x74, 0xb7, 0x03, 0xc5, 0x75,
0xba, 0x49, 0xdd, 0x45, 0x3b, 0x9a, 0xec, 0x95, 0x0f, 0x82, 0x7d, 0xea, 0xaa, 0xd9, 0xc5, 0xcb,
0x30, 0xde, 0x55, 0xb0, 0xa3, 0xa9, 0x7e, 0x51, 0x50, 0x65, 0xc3, 0xf5, 0xba, 0x78, 0x1e, 0x12,
0xb4, 0xf8, 0x46, 0xc3, 0x7f, 0x49, 0xc0, 0x99, 0x7a, 0xf1, 0x13, 0x90, 0x92, 0x45, 0x37, 0x1a,
0xfa, 0xcb, 0x02, 0x1a, 0x40, 0x28, 0x5c, 0x16, 0xdc, 0x68, 0xf8, 0xe7, 0x24, 0x5c, 0x42, 0x28,
0x7c, 0x78, 0x17, 0x7e, 0xf7, 0x0b, 0x09, 0x91, 0x34, 0xa5, 0xef, 0x2e, 0xc1, 0x98, 0xa8, 0xb4,
0xd1, 0xe8, 0xcf, 0x8b, 0x87, 0x4b, 0x44, 0xf1, 0x29, 0x48, 0x0e, 0xe9, 0xf0, 0x5f, 0x15, 0x50,
0xae, 0x5f, 0x5c, 0x86, 0x4c, 0xa8, 0xba, 0x46, 0xc3, 0x7f, 0x4d, 0xc0, 0xc3, 0x28, 0x6a, 0xba,
0xa8, 0xae, 0xd1, 0x04, 0xbf, 0x2e, 0x4d, 0x17, 0x08, 0xea, 0x36, 0x59, 0x58, 0xa3, 0xd1, 0xbf,
0x21, 0xbd, 0x2e, 0x21, 0xc5, 0x67, 0x21, 0x1d, 0x24, 0xcb, 0x68, 0xfc, 0x6f, 0x0a, 0x7c, 0x07,
0x43, 0x3d, 0x10, 0x4a, 0xd6, 0xd1, 0x14, 0xbf, 0x25, 0x3d, 0x10, 0x42, 0xd1, 0x63, 0xd4, 0x5b,
0x80, 0xa3, 0x99, 0x7e, 0x5b, 0x1e, 0xa3, 0x9e, 0xfa, 0x4b, 0x77, 0x93, 0xe5, 0xac, 0x68, 0x8a,
0xdf, 0x91, 0xbb, 0xc9, 0xf4, 0xa9, 0x19, 0xbd, 0x15, 0x2d, 0x9a, 0xe3, 0x77, 0xa5, 0x19, 0x3d,
0x05, 0xad, 0xb8, 0x05, 0xa8, 0xbf, 0x9a, 0x45, 0xf3, 0x7d, 0x51, 0xf0, 0x4d, 0xf6, 0x15, 0xb3,
0xe2, 0x73, 0x70, 0x62, 0x70, 0x25, 0x8b, 0x66, 0xfd, 0xd2, 0x07, 0x3d, 0xef, 0x1e, 0xe1, 0x42,
0x56, 0xdc, 0xe9, 0xbc, 0x7b, 0x84, 0xab, 0x58, 0x34, 0xed, 0xab, 0x1f, 0x74, 0xbf, 0x9a, 0x86,
0x8b, 0x58, 0xb1, 0x04, 0xd0, 0x29, 0x20, 0xd1, 0x5c, 0xaf, 0x09, 0xae, 0x10, 0x88, 0x1e, 0x0d,
0x51, 0x3f, 0xa2, 0xf1, 0x5f, 0x91, 0x47, 0x43, 0x20, 0xe8, 0xd1, 0x90, 0xa5, 0x23, 0x1a, 0xfd,
0xba, 0x3c, 0x1a, 0x12, 0x52, 0xbc, 0x04, 0x29, 0xbb, 0x65, 0x59, 0x34, 0xb6, 0xd0, 0xdd, 0x7f,
0x11, 0x93, 0xff, 0xd1, 0x87, 0x02, 0x2c, 0x01, 0xc5, 0xf3, 0x90, 0x24, 0x8d, 0x3d, 0x52, 0x8b,
0x42, 0xfe, 0xcb, 0x87, 0x32, 0x9f, 0x50, 0xed, 0xe2, 0xb3, 0x00, 0xfc, 0xcd, 0x97, 0x7d, 0x10,
0x89, 0xc0, 0xfe, 0xeb, 0x87, 0xe2, 0x63, 0x7b, 0x07, 0xd2, 0x21, 0xe0, 0x9f, 0xee, 0xef, 0x4e,
0xf0, 0x5e, 0x37, 0x01, 0x7b, 0x5b, 0x7e, 0x1a, 0xc6, 0xae, 0x7a, 0x8e, 0xed, 0xe3, 0x7a, 0x14,
0xfa, 0xdf, 0x04, 0x5a, 0xea, 0x53, 0x87, 0x35, 0x1c, 0x97, 0xf8, 0xb8, 0xee, 0x45, 0x61, 0xff,
0x5d, 0x60, 0x03, 0x00, 0x05, 0x1b, 0xd8, 0xf3, 0x87, 0x59, 0xf7, 0x7f, 0x48, 0xb0, 0x04, 0x50,
0xa3, 0xe9, 0xff, 0xd7, 0x48, 0x3b, 0x0a, 0xfb, 0xbe, 0x34, 0x5a, 0xe8, 0x17, 0x3f, 0x01, 0x69,
0xfa, 0x2f, 0xff, 0x01, 0x4a, 0x04, 0xf8, 0x3f, 0x05, 0xb8, 0x83, 0xa0, 0x4f, 0xf6, 0xfc, 0x9a,
0x6f, 0x46, 0x3b, 0xfb, 0xbf, 0xc4, 0x4e, 0x4b, 0xfd, 0x62, 0x09, 0x32, 0x9e, 0x5f, 0xab, 0xb5,
0x5c, 0x7e, 0x13, 0x17, 0x01, 0xff, 0xef, 0x0f, 0x83, 0x37, 0xd2, 0x00, 0x53, 0x3e, 0x35, 0xf8,
0x72, 0x0d, 0x56, 0x9d, 0x55, 0x87, 0x5f, 0xab, 0xc1, 0x77, 0x26, 0xe0, 0xb4, 0xe1, 0x34, 0xf6,
0x1c, 0xef, 0x0c, 0x4f, 0x28, 0x41, 0x3a, 0x39, 0x23, 0xdd, 0x27, 0xae, 0xc6, 0x02, 0x77, 0xce,
0x1c, 0xef, 0x4e, 0x6d, 0xfe, 0x47, 0xe3, 0x90, 0x5a, 0xc6, 0x9e, 0x8f, 0x6f, 0xe0, 0x36, 0x3a,
0x0d, 0xa9, 0x35, 0xdb, 0x3f, 0x77, 0x76, 0xcb, 0x77, 0xd9, 0x17, 0x95, 0x78, 0x39, 0x7d, 0xe7,
0xd6, 0x6c, 0xd2, 0xa4, 0x32, 0x2d, 0x98, 0x42, 0x0f, 0x41, 0x92, 0xfd, 0xcf, 0x6e, 0x16, 0xe3,
0xe5, 0xf1, 0xb7, 0x6e, 0xcd, 0x8e, 0x74, 0xf4, 0xf8, 0x1c, 0x7a, 0x01, 0x32, 0xd5, 0xf6, 0xae,
0x69, 0xfb, 0x17, 0x96, 0x28, 0x1d, 0x75, 0x40, 0xa2, 0xfc, 0xd4, 0x9d, 0x5b, 0xb3, 0xe7, 0x8e,
0x34, 0x90, 0x96, 0xc5, 0xce, 0xc2, 0x24, 0x9a, 0xfd, 0x10, 0x2f, 0xcc, 0x85, 0x9e, 0x83, 0x94,
0x1c, 0xf2, 0x1b, 0xfa, 0xf2, 0x25, 0x61, 0xc2, 0x3d, 0x71, 0x07, 0x64, 0xe8, 0xff, 0x43, 0xb6,
0xda, 0xbe, 0x6c, 0x39, 0x58, 0xf8, 0x20, 0x39, 0xa7, 0x2c, 0xc4, 0xca, 0x17, 0xef, 0xdc, 0x9a,
0x5d, 0x1a, 0x9a, 0x58, 0xc0, 0x19, 0x73, 0x17, 0x1b, 0x7a, 0x11, 0xd2, 0xc1, 0x98, 0x7d, 0x03,
0x88, 0x95, 0x3f, 0x2e, 0xec, 0xbe, 0x37, 0xfa, 0x0e, 0x5d, 0xc8, 0x72, 0xee, 0xee, 0xb1, 0x39,
0x65, 0x41, 0xb9, 0x17, 0xcb, 0x85, 0x4f, 0xba, 0xd8, 0x42, 0x96, 0x5f, 0x58, 0x62, 0x1f, 0x1d,
0x94, 0x7b, 0xb5, 0x5c, 0xd0, 0x77, 0xe8, 0xd0, 0x15, 0x18, 0xab, 0xb6, 0xcb, 0x6d, 0x9f, 0x78,
0xec, 0xd7, 0x29, 0xd9, 0xf2, 0x93, 0x77, 0x6e, 0xcd, 0x7e, 0x74, 0x48, 0x56, 0x86, 0xd3, 0x24,
0x01, 0x9a, 0x83, 0xcc, 0x86, 0xe3, 0x36, 0xb0, 0xc5, 0xf9, 0x80, 0x7f, 0x44, 0x09, 0x89, 0xd0,
0x2e, 0x5d, 0x09, 0xdf, 0x6d, 0x8f, 0xfd, 0xb4, 0xfe, 0x27, 0x88, 0xc9, 0x0e, 0x13, 0x32, 0x21,
0x59, 0x6d, 0x57, 0x71, 0x33, 0x9f, 0x65, 0x37, 0xfc, 0x0f, 0x2e, 0x06, 0x08, 0x79, 0xb6, 0x16,
0xd9, 0x3c, 0xfb, 0x15, 0x41, 0x79, 0xe9, 0xce, 0xad, 0xd9, 0x27, 0x87, 0x7e, 0x62, 0x15, 0x37,
0xd9, 0xe3, 0xf8, 0x13, 0xd0, 0xb7, 0x14, 0x7a, 0xb0, 0xf8, 0x15, 0x29, 0x7d, 0xe2, 0x38, 0x7b,
0xe2, 0x43, 0x03, 0x9f, 0x18, 0x68, 0xf1, 0xe7, 0xda, 0x9f, 0x7d, 0xfb, 0x18, 0x2b, 0xe5, 0x6f,
0x36, 0xf4, 0xd1, 0xbf, 0xf2, 0xf6, 0x3d, 0x1f, 0xda, 0xc0, 0x02, 0xf4, 0x8a, 0x02, 0xe3, 0xd5,
0xf6, 0x86, 0xa8, 0xb1, 0xd4, 0xf2, 0x9c, 0xf8, 0x01, 0xf6, 0x20, 0xcb, 0x43, 0x7a, 0xdc, 0xf6,
0x0b, 0x9f, 0x7d, 0x7b, 0xf6, 0xec, 0xd0, 0x46, 0xb0, 0x14, 0xc4, 0x6c, 0xe8, 0x7e, 0x26, 0xfa,
0x1c, 0xb3, 0xa2, 0x42, 0xeb, 0x75, 0x8d, 0xd4, 0xa8, 0x15, 0x13, 0x77, 0xb1, 0x22, 0xa4, 0xc7,
0xad, 0x28, 0xd2, 0xa8, 0xbf, 0x77, 0x4b, 0x42, 0x7c, 0x68, 0x13, 0x46, 0xb9, 0x87, 0xd9, 0x2f,
0xa3, 0xd2, 0xc7, 0x0c, 0xc3, 0xce, 0xe6, 0x68, 0x82, 0x66, 0xe6, 0x22, 0x40, 0x27, 0xc6, 0x90,
0x0a, 0xf1, 0x6b, 0xa4, 0x2d, 0x7e, 0x01, 0x47, 0xff, 0x45, 0xd3, 0x9d, 0x5f, 0x78, 0x2a, 0x0b,
0x09, 0xf1, 0xb3, 0xcd, 0x62, 0xec, 0xa2, 0x32, 0xf3, 0x0c, 0xa8, 0xbd, 0xb1, 0x72, 0x2c, 0xbc,
0x06, 0xa8, 0x7f, 0xc7, 0xc2, 0x0c, 0x49, 0xce, 0xf0, 0x48, 0x98, 0x21, 0x73, 0x56, 0xed, 0xf8,
0xfc, 0x39, 0xd3, 0xf2, 0x1c, 0xbb, 0x8f, 0xb3, 0xd7, 0xff, 0x3f, 0x19, 0xe7, 0x7c, 0x01, 0x46,
0xb9, 0x90, 0xae, 0x65, 0x8d, 0x95, 0x0f, 0x56, 0xe5, 0x34, 0x3e, 0x28, 0xaf, 0xbf, 0x75, 0xbb,
0x30, 0xf2, 0xfd, 0xdb, 0x85, 0x91, 0x7f, 0xb8, 0x5d, 0x18, 0xf9, 0xe1, 0xed, 0x82, 0xf2, 0xee,
0xed, 0x82, 0xf2, 0xfe, 0xed, 0x82, 0xf2, 0xe3, 0xdb, 0x05, 0xe5, 0xe6, 0x61, 0x41, 0xf9, 0xda,
0x61, 0x41, 0xf9, 0xc6, 0x61, 0x41, 0xf9, 0x9b, 0xc3, 0x82, 0xf2, 0xdd, 0xc3, 0x82, 0xf2, 0xd6,
0x61, 0x61, 0xe4, 0xfb, 0x87, 0x85, 0x91, 0x1f, 0x1e, 0x16, 0x94, 0x77, 0x0f, 0x0b, 0x23, 0xef,
0x1f, 0x16, 0x94, 0x1f, 0x1f, 0x16, 0x94, 0x9b, 0xff, 0x54, 0x18, 0xf9, 0xdf, 0x00, 0x00, 0x00,
0xff, 0xff, 0xeb, 0x34, 0x72, 0x4f, 0xe4, 0x34, 0x00, 0x00,
}
r := bytes.NewReader(gzipped)
gzipr, err := compress_gzip.NewReader(r)
if err != nil {
panic(err)
}
ungzipped, err := io_ioutil.ReadAll(gzipr)
if err != nil {
panic(err)
}
if err := <API key>.Unmarshal(ungzipped, d); err != nil {
panic(err)
}
return d
}
func (this *Castaway) VerboseEqual(that interface{}) error {
if that == nil {
if this == nil {
return nil
}
return fmt.Errorf("that == nil && this != nil")
}
that1, ok := that.(*Castaway)
if !ok {
that2, ok := that.(Castaway)
if ok {
that1 = &that2
} else {
return fmt.Errorf("that is not of type *Castaway")
}
}
if that1 == nil {
if this == nil {
return nil
}
return fmt.Errorf("that is type *Castaway but is nil && this != nil")
} else if this == nil {
return fmt.Errorf("that is type *Castaway but is not nil && this == nil")
}
if this.Int32Ptr != nil && that1.Int32Ptr != nil {
if *this.Int32Ptr != *that1.Int32Ptr {
return fmt.Errorf("Int32Ptr this(%v) Not Equal that(%v)", *this.Int32Ptr, *that1.Int32Ptr)
}
} else if this.Int32Ptr != nil {
return fmt.Errorf("this.Int32Ptr == nil && that.Int32Ptr != nil")
} else if that1.Int32Ptr != nil {
return fmt.Errorf("Int32Ptr this(%v) Not Equal that(%v)", this.Int32Ptr, that1.Int32Ptr)
}
if this.Int32 != that1.Int32 {
return fmt.Errorf("Int32 this(%v) Not Equal that(%v)", this.Int32, that1.Int32)
}
if this.MyUint64Ptr != nil && that1.MyUint64Ptr != nil {
if *this.MyUint64Ptr != *that1.MyUint64Ptr {
return fmt.Errorf("MyUint64Ptr this(%v) Not Equal that(%v)", *this.MyUint64Ptr, *that1.MyUint64Ptr)
}
} else if this.MyUint64Ptr != nil {
return fmt.Errorf("this.MyUint64Ptr == nil && that.MyUint64Ptr != nil")
} else if that1.MyUint64Ptr != nil {
return fmt.Errorf("MyUint64Ptr this(%v) Not Equal that(%v)", this.MyUint64Ptr, that1.MyUint64Ptr)
}
if this.MyUint64 != that1.MyUint64 {
return fmt.Errorf("MyUint64 this(%v) Not Equal that(%v)", this.MyUint64, that1.MyUint64)
}
if this.MyFloat32Ptr != nil && that1.MyFloat32Ptr != nil {
if *this.MyFloat32Ptr != *that1.MyFloat32Ptr {
return fmt.Errorf("MyFloat32Ptr this(%v) Not Equal that(%v)", *this.MyFloat32Ptr, *that1.MyFloat32Ptr)
}
} else if this.MyFloat32Ptr != nil {
return fmt.Errorf("this.MyFloat32Ptr == nil && that.MyFloat32Ptr != nil")
} else if that1.MyFloat32Ptr != nil {
return fmt.Errorf("MyFloat32Ptr this(%v) Not Equal that(%v)", this.MyFloat32Ptr, that1.MyFloat32Ptr)
}
if this.MyFloat32 != that1.MyFloat32 {
return fmt.Errorf("MyFloat32 this(%v) Not Equal that(%v)", this.MyFloat32, that1.MyFloat32)
}
if this.MyFloat64Ptr != nil && that1.MyFloat64Ptr != nil {
if *this.MyFloat64Ptr != *that1.MyFloat64Ptr {
return fmt.Errorf("MyFloat64Ptr this(%v) Not Equal that(%v)", *this.MyFloat64Ptr, *that1.MyFloat64Ptr)
}
} else if this.MyFloat64Ptr != nil {
return fmt.Errorf("this.MyFloat64Ptr == nil && that.MyFloat64Ptr != nil")
} else if that1.MyFloat64Ptr != nil {
return fmt.Errorf("MyFloat64Ptr this(%v) Not Equal that(%v)", this.MyFloat64Ptr, that1.MyFloat64Ptr)
}
if this.MyFloat64 != that1.MyFloat64 {
return fmt.Errorf("MyFloat64 this(%v) Not Equal that(%v)", this.MyFloat64, that1.MyFloat64)
}
if !bytes.Equal(this.MyBytes, that1.MyBytes) {
return fmt.Errorf("MyBytes this(%v) Not Equal that(%v)", this.MyBytes, that1.MyBytes)
}
if !bytes.Equal(this.NormalBytes, that1.NormalBytes) {
return fmt.Errorf("NormalBytes this(%v) Not Equal that(%v)", this.NormalBytes, that1.NormalBytes)
}
if len(this.MyUint64S) != len(that1.MyUint64S) {
return fmt.Errorf("MyUint64S this(%v) Not Equal that(%v)", len(this.MyUint64S), len(that1.MyUint64S))
}
for i := range this.MyUint64S {
if this.MyUint64S[i] != that1.MyUint64S[i] {
return fmt.Errorf("MyUint64S this[%v](%v) Not Equal that[%v](%v)", i, this.MyUint64S[i], i, that1.MyUint64S[i])
}
}
if len(this.MyMap) != len(that1.MyMap) {
return fmt.Errorf("MyMap this(%v) Not Equal that(%v)", len(this.MyMap), len(that1.MyMap))
}
for i := range this.MyMap {
if this.MyMap[i] != that1.MyMap[i] {
return fmt.Errorf("MyMap this[%v](%v) Not Equal that[%v](%v)", i, this.MyMap[i], i, that1.MyMap[i])
}
}
if len(this.MyCustomMap) != len(that1.MyCustomMap) {
return fmt.Errorf("MyCustomMap this(%v) Not Equal that(%v)", len(this.MyCustomMap), len(that1.MyCustomMap))
}
for i := range this.MyCustomMap {
if this.MyCustomMap[i] != that1.MyCustomMap[i] {
return fmt.Errorf("MyCustomMap this[%v](%v) Not Equal that[%v](%v)", i, this.MyCustomMap[i], i, that1.MyCustomMap[i])
}
}
if len(this.MyNullableMap) != len(that1.MyNullableMap) {
return fmt.Errorf("MyNullableMap this(%v) Not Equal that(%v)", len(this.MyNullableMap), len(that1.MyNullableMap))
}
for i := range this.MyNullableMap {
if !this.MyNullableMap[i].Equal(that1.MyNullableMap[i]) {
return fmt.Errorf("MyNullableMap this[%v](%v) Not Equal that[%v](%v)", i, this.MyNullableMap[i], i, that1.MyNullableMap[i])
}
}
if len(this.MyEmbeddedMap) != len(that1.MyEmbeddedMap) {
return fmt.Errorf("MyEmbeddedMap this(%v) Not Equal that(%v)", len(this.MyEmbeddedMap), len(that1.MyEmbeddedMap))
}
for i := range this.MyEmbeddedMap {
a := this.MyEmbeddedMap[i]
b := that1.MyEmbeddedMap[i]
if !(&a).Equal(&b) {
return fmt.Errorf("MyEmbeddedMap this[%v](%v) Not Equal that[%v](%v)", i, this.MyEmbeddedMap[i], i, that1.MyEmbeddedMap[i])
}
}
if this.String_ != nil && that1.String_ != nil {
if *this.String_ != *that1.String_ {
return fmt.Errorf("String_ this(%v) Not Equal that(%v)", *this.String_, *that1.String_)
}
} else if this.String_ != nil {
return fmt.Errorf("this.String_ == nil && that.String_ != nil")
} else if that1.String_ != nil {
return fmt.Errorf("String_ this(%v) Not Equal that(%v)", this.String_, that1.String_)
}
if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
}
return nil
}
func (this *Castaway) Equal(that interface{}) bool {
if that == nil {
if this == nil {
return true
}
return false
}
that1, ok := that.(*Castaway)
if !ok {
that2, ok := that.(Castaway)
if ok {
that1 = &that2
} else {
return false
}
}
if that1 == nil {
if this == nil {
return true
}
return false
} else if this == nil {
return false
}
if this.Int32Ptr != nil && that1.Int32Ptr != nil {
if *this.Int32Ptr != *that1.Int32Ptr {
return false
}
} else if this.Int32Ptr != nil {
return false
} else if that1.Int32Ptr != nil {
return false
}
if this.Int32 != that1.Int32 {
return false
}
if this.MyUint64Ptr != nil && that1.MyUint64Ptr != nil {
if *this.MyUint64Ptr != *that1.MyUint64Ptr {
return false
}
} else if this.MyUint64Ptr != nil {
return false
} else if that1.MyUint64Ptr != nil {
return false
}
if this.MyUint64 != that1.MyUint64 {
return false
}
if this.MyFloat32Ptr != nil && that1.MyFloat32Ptr != nil {
if *this.MyFloat32Ptr != *that1.MyFloat32Ptr {
return false
}
} else if this.MyFloat32Ptr != nil {
return false
} else if that1.MyFloat32Ptr != nil {
return false
}
if this.MyFloat32 != that1.MyFloat32 {
return false
}
if this.MyFloat64Ptr != nil && that1.MyFloat64Ptr != nil {
if *this.MyFloat64Ptr != *that1.MyFloat64Ptr {
return false
}
} else if this.MyFloat64Ptr != nil {
return false
} else if that1.MyFloat64Ptr != nil {
return false
}
if this.MyFloat64 != that1.MyFloat64 {
return false
}
if !bytes.Equal(this.MyBytes, that1.MyBytes) {
return false
}
if !bytes.Equal(this.NormalBytes, that1.NormalBytes) {
return false
}
if len(this.MyUint64S) != len(that1.MyUint64S) {
return false
}
for i := range this.MyUint64S {
if this.MyUint64S[i] != that1.MyUint64S[i] {
return false
}
}
if len(this.MyMap) != len(that1.MyMap) {
return false
}
for i := range this.MyMap {
if this.MyMap[i] != that1.MyMap[i] {
return false
}
}
if len(this.MyCustomMap) != len(that1.MyCustomMap) {
return false
}
for i := range this.MyCustomMap {
if this.MyCustomMap[i] != that1.MyCustomMap[i] {
return false
}
}
if len(this.MyNullableMap) != len(that1.MyNullableMap) {
return false
}
for i := range this.MyNullableMap {
if !this.MyNullableMap[i].Equal(that1.MyNullableMap[i]) {
return false
}
}
if len(this.MyEmbeddedMap) != len(that1.MyEmbeddedMap) {
return false
}
for i := range this.MyEmbeddedMap {
a := this.MyEmbeddedMap[i]
b := that1.MyEmbeddedMap[i]
if !(&a).Equal(&b) {
return false
}
}
if this.String_ != nil && that1.String_ != nil {
if *this.String_ != *that1.String_ {
return false
}
} else if this.String_ != nil {
return false
} else if that1.String_ != nil {
return false
}
if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
return false
}
return true
}
func (this *Wilson) VerboseEqual(that interface{}) error {
if that == nil {
if this == nil {
return nil
}
return fmt.Errorf("that == nil && this != nil")
}
that1, ok := that.(*Wilson)
if !ok {
that2, ok := that.(Wilson)
if ok {
that1 = &that2
} else {
return fmt.Errorf("that is not of type *Wilson")
}
}
if that1 == nil {
if this == nil {
return nil
}
return fmt.Errorf("that is type *Wilson but is nil && this != nil")
} else if this == nil {
return fmt.Errorf("that is type *Wilson but is not nil && this == nil")
}
if this.Int64 != nil && that1.Int64 != nil {
if *this.Int64 != *that1.Int64 {
return fmt.Errorf("Int64 this(%v) Not Equal that(%v)", *this.Int64, *that1.Int64)
}
} else if this.Int64 != nil {
return fmt.Errorf("this.Int64 == nil && that.Int64 != nil")
} else if that1.Int64 != nil {
return fmt.Errorf("Int64 this(%v) Not Equal that(%v)", this.Int64, that1.Int64)
}
if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
}
return nil
}
func (this *Wilson) Equal(that interface{}) bool {
if that == nil {
if this == nil {
return true
}
return false
}
that1, ok := that.(*Wilson)
if !ok {
that2, ok := that.(Wilson)
if ok {
that1 = &that2
} else {
return false
}
}
if that1 == nil {
if this == nil {
return true
}
return false
} else if this == nil {
return false
}
if this.Int64 != nil && that1.Int64 != nil {
if *this.Int64 != *that1.Int64 {
return false
}
} else if this.Int64 != nil {
return false
} else if that1.Int64 != nil {
return false
}
if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
return false
}
return true
}
type CastawayFace interface {
Proto() <API key>.Message
GetInt32Ptr() *int32
GetInt32() int32
GetMyUint64Ptr() *<API key>.MyUint64Type
GetMyUint64() <API key>.MyUint64Type
GetMyFloat32Ptr() *<API key>.MyFloat32Type
GetMyFloat32() <API key>.MyFloat32Type
GetMyFloat64Ptr() *<API key>.MyFloat64Type
GetMyFloat64() <API key>.MyFloat64Type
GetMyBytes() <API key>.Bytes
GetNormalBytes() []byte
GetMyUint64S() []<API key>.MyUint64Type
GetMyMap() <API key>.MyMapType
GetMyCustomMap() map[<API key>.MyStringType]<API key>.MyUint64Type
GetMyNullableMap() map[<API key>.MyInt32Type]*Wilson
GetMyEmbeddedMap() map[<API key>.MyInt32Type]Wilson
GetString_() *<API key>.MyStringType
}
func (this *Castaway) Proto() <API key>.Message {
return this
}
func (this *Castaway) TestProto() <API key>.Message {
return NewCastawayFromFace(this)
}
func (this *Castaway) GetInt32Ptr() *int32 {
return this.Int32Ptr
}
func (this *Castaway) GetInt32() int32 {
return this.Int32
}
func (this *Castaway) GetMyUint64Ptr() *<API key>.MyUint64Type {
return this.MyUint64Ptr
}
func (this *Castaway) GetMyUint64() <API key>.MyUint64Type {
return this.MyUint64
}
func (this *Castaway) GetMyFloat32Ptr() *<API key>.MyFloat32Type {
return this.MyFloat32Ptr
}
func (this *Castaway) GetMyFloat32() <API key>.MyFloat32Type {
return this.MyFloat32
}
func (this *Castaway) GetMyFloat64Ptr() *<API key>.MyFloat64Type {
return this.MyFloat64Ptr
}
func (this *Castaway) GetMyFloat64() <API key>.MyFloat64Type {
return this.MyFloat64
}
func (this *Castaway) GetMyBytes() <API key>.Bytes {
return this.MyBytes
}
func (this *Castaway) GetNormalBytes() []byte {
return this.NormalBytes
}
func (this *Castaway) GetMyUint64S() []<API key>.MyUint64Type {
return this.MyUint64S
}
func (this *Castaway) GetMyMap() <API key>.MyMapType {
return this.MyMap
}
func (this *Castaway) GetMyCustomMap() map[<API key>.MyStringType]<API key>.MyUint64Type {
return this.MyCustomMap
}
func (this *Castaway) GetMyNullableMap() map[<API key>.MyInt32Type]*Wilson {
return this.MyNullableMap
}
func (this *Castaway) GetMyEmbeddedMap() map[<API key>.MyInt32Type]Wilson {
return this.MyEmbeddedMap
}
func (this *Castaway) GetString_() *<API key>.MyStringType {
return this.String_
}
func NewCastawayFromFace(that CastawayFace) *Castaway {
this := &Castaway{}
this.Int32Ptr = that.GetInt32Ptr()
this.Int32 = that.GetInt32()
this.MyUint64Ptr = that.GetMyUint64Ptr()
this.MyUint64 = that.GetMyUint64()
this.MyFloat32Ptr = that.GetMyFloat32Ptr()
this.MyFloat32 = that.GetMyFloat32()
this.MyFloat64Ptr = that.GetMyFloat64Ptr()
this.MyFloat64 = that.GetMyFloat64()
this.MyBytes = that.GetMyBytes()
this.NormalBytes = that.GetNormalBytes()
this.MyUint64S = that.GetMyUint64S()
this.MyMap = that.GetMyMap()
this.MyCustomMap = that.GetMyCustomMap()
this.MyNullableMap = that.GetMyNullableMap()
this.MyEmbeddedMap = that.GetMyEmbeddedMap()
this.String_ = that.GetString_()
return this
}
type WilsonFace interface {
Proto() <API key>.Message
GetInt64() *int64
}
func (this *Wilson) Proto() <API key>.Message {
return this
}
func (this *Wilson) TestProto() <API key>.Message {
return NewWilsonFromFace(this)
}
func (this *Wilson) GetInt64() *int64 {
return this.Int64
}
func NewWilsonFromFace(that WilsonFace) *Wilson {
this := &Wilson{}
this.Int64 = that.GetInt64()
return this
}
func (this *Castaway) GoString() string {
if this == nil {
return "nil"
}
s := make([]string, 0, 20)
s = append(s, "&casttype.Castaway{")
if this.Int32Ptr != nil {
s = append(s, "Int32Ptr: "+<API key>(this.Int32Ptr, "int32")+",\n")
}
s = append(s, "Int32: "+fmt.Sprintf("%#v", this.Int32)+",\n")
if this.MyUint64Ptr != nil {
s = append(s, "MyUint64Ptr: "+<API key>(this.MyUint64Ptr, "<API key>.MyUint64Type")+",\n")
}
s = append(s, "MyUint64: "+fmt.Sprintf("%#v", this.MyUint64)+",\n")
if this.MyFloat32Ptr != nil {
s = append(s, "MyFloat32Ptr: "+<API key>(this.MyFloat32Ptr, "<API key>.MyFloat32Type")+",\n")
}
s = append(s, "MyFloat32: "+fmt.Sprintf("%#v", this.MyFloat32)+",\n")
if this.MyFloat64Ptr != nil {
s = append(s, "MyFloat64Ptr: "+<API key>(this.MyFloat64Ptr, "<API key>.MyFloat64Type")+",\n")
}
s = append(s, "MyFloat64: "+fmt.Sprintf("%#v", this.MyFloat64)+",\n")
if this.MyBytes != nil {
s = append(s, "MyBytes: "+<API key>(this.MyBytes, "<API key>.Bytes")+",\n")
}
if this.NormalBytes != nil {
s = append(s, "NormalBytes: "+<API key>(this.NormalBytes, "byte")+",\n")
}
if this.MyUint64S != nil {
s = append(s, "MyUint64S: "+fmt.Sprintf("%#v", this.MyUint64S)+",\n")
}
keysForMyMap := make([]string, 0, len(this.MyMap))
for k := range this.MyMap {
keysForMyMap = append(keysForMyMap, k)
}
<API key>.Strings(keysForMyMap)
mapStringForMyMap := "<API key>.MyMapType{"
for _, k := range keysForMyMap {
mapStringForMyMap += fmt.Sprintf("%#v: %#v,", k, this.MyMap[k])
}
mapStringForMyMap += "}"
if this.MyMap != nil {
s = append(s, "MyMap: "+mapStringForMyMap+",\n")
}
keysForMyCustomMap := make([]string, 0, len(this.MyCustomMap))
for k := range this.MyCustomMap {
keysForMyCustomMap = append(keysForMyCustomMap, string(k))
}
<API key>.Strings(keysForMyCustomMap)
<API key> := "map[<API key>.MyStringType]<API key>.MyUint64Type{"
for _, k := range keysForMyCustomMap {
<API key> += fmt.Sprintf("%#v: %#v,", k, this.MyCustomMap[<API key>.MyStringType(k)])
}
<API key> += "}"
if this.MyCustomMap != nil {
s = append(s, "MyCustomMap: "+<API key>+",\n")
}
<API key> := make([]int32, 0, len(this.MyNullableMap))
for k := range this.MyNullableMap {
<API key> = append(<API key>, int32(k))
}
<API key>.Int32s(<API key>)
<API key> := "map[<API key>.MyInt32Type]*Wilson{"
for _, k := range <API key> {
<API key> += fmt.Sprintf("%#v: %#v,", k, this.MyNullableMap[<API key>.MyInt32Type(k)])
}
<API key> += "}"
if this.MyNullableMap != nil {
s = append(s, "MyNullableMap: "+<API key>+",\n")
}
<API key> := make([]int32, 0, len(this.MyEmbeddedMap))
for k := range this.MyEmbeddedMap {
<API key> = append(<API key>, int32(k))
}
<API key>.Int32s(<API key>)
<API key> := "map[<API key>.MyInt32Type]Wilson{"
for _, k := range <API key> {
<API key> += fmt.Sprintf("%#v: %#v,", k, this.MyEmbeddedMap[<API key>.MyInt32Type(k)])
}
<API key> += "}"
if this.MyEmbeddedMap != nil {
s = append(s, "MyEmbeddedMap: "+<API key>+",\n")
}
if this.String_ != nil {
s = append(s, "String_: "+<API key>(this.String_, "<API key>.MyStringType")+",\n")
}
if this.XXX_unrecognized != nil {
s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
}
s = append(s, "}")
return strings.Join(s, "")
}
func (this *Wilson) GoString() string {
if this == nil {
return "nil"
}
s := make([]string, 0, 5)
s = append(s, "&casttype.Wilson{")
if this.Int64 != nil {
s = append(s, "Int64: "+<API key>(this.Int64, "int64")+",\n")
}
if this.XXX_unrecognized != nil {
s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
}
s = append(s, "}")
return strings.Join(s, "")
}
func <API key>(v interface{}, typ string) string {
rv := reflect.ValueOf(v)
if rv.IsNil() {
return "nil"
}
pv := reflect.Indirect(rv).Interface()
return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv)
}
func <API key>(r randyCasttype, easy bool) *Castaway {
this := &Castaway{}
if r.Intn(10) != 0 {
v1 := int32(r.Int63())
if r.Intn(2) == 0 {
v1 *= -1
}
this.Int32Ptr = &v1
}
this.Int32 = int32(r.Int63())
if r.Intn(2) == 0 {
this.Int32 *= -1
}
if r.Intn(10) != 0 {
v2 := <API key>.MyUint64Type(uint64(r.Uint32()))
this.MyUint64Ptr = &v2
}
this.MyUint64 = <API key>.MyUint64Type(uint64(r.Uint32()))
if r.Intn(10) != 0 {
v3 := <API key>.MyFloat32Type(r.Float32())
if r.Intn(2) == 0 {
v3 *= -1
}
this.MyFloat32Ptr = &v3
}
this.MyFloat32 = <API key>.MyFloat32Type(r.Float32())
if r.Intn(2) == 0 {
this.MyFloat32 *= -1
}
if r.Intn(10) != 0 {
v4 := <API key>.MyFloat64Type(r.Float64())
if r.Intn(2) == 0 {
v4 *= -1
}
this.MyFloat64Ptr = &v4
}
this.MyFloat64 = <API key>.MyFloat64Type(r.Float64())
if r.Intn(2) == 0 {
this.MyFloat64 *= -1
}
if r.Intn(10) != 0 {
v5 := r.Intn(100)
this.MyBytes = make(<API key>.Bytes, v5)
for i := 0; i < v5; i++ {
this.MyBytes[i] = byte(r.Intn(256))
}
}
if r.Intn(10) != 0 {
v6 := r.Intn(100)
this.NormalBytes = make([]byte, v6)
for i := 0; i < v6; i++ {
this.NormalBytes[i] = byte(r.Intn(256))
}
}
if r.Intn(10) != 0 {
v7 := r.Intn(10)
this.MyUint64S = make([]<API key>.MyUint64Type, v7)
for i := 0; i < v7; i++ {
this.MyUint64S[i] = <API key>.MyUint64Type(uint64(r.Uint32()))
}
}
if r.Intn(10) != 0 {
v8 := r.Intn(10)
this.MyMap = make(<API key>.MyMapType)
for i := 0; i < v8; i++ {
v9 := randStringCasttype(r)
this.MyMap[v9] = uint64(uint64(r.Uint32()))
}
}
if r.Intn(10) != 0 {
v10 := r.Intn(10)
this.MyCustomMap = make(map[<API key>.MyStringType]<API key>.MyUint64Type)
for i := 0; i < v10; i++ {
v11 := <API key>.MyStringType(randStringCasttype(r))
this.MyCustomMap[v11] = <API key>.MyUint64Type(uint64(r.Uint32()))
}
}
if r.Intn(10) != 0 {
v12 := r.Intn(10)
this.MyNullableMap = make(map[<API key>.MyInt32Type]*Wilson)
for i := 0; i < v12; i++ {
this.MyNullableMap[<API key>.MyInt32Type(int32(r.Int31()))] = NewPopulatedWilson(r, easy)
}
}
if r.Intn(10) != 0 {
v13 := r.Intn(10)
this.MyEmbeddedMap = make(map[<API key>.MyInt32Type]Wilson)
for i := 0; i < v13; i++ {
this.MyEmbeddedMap[<API key>.MyInt32Type(int32(r.Int31()))] = *NewPopulatedWilson(r, easy)
}
}
if r.Intn(10) != 0 {
v14 := <API key>.MyStringType(randStringCasttype(r))
this.String_ = &v14
}
if !easy && r.Intn(10) != 0 {
this.XXX_unrecognized = <API key>(r, 17)
}
return this
}
func NewPopulatedWilson(r randyCasttype, easy bool) *Wilson {
this := &Wilson{}
if r.Intn(10) != 0 {
v15 := int64(r.Int63())
if r.Intn(2) == 0 {
v15 *= -1
}
this.Int64 = &v15
}
if !easy && r.Intn(10) != 0 {
this.XXX_unrecognized = <API key>(r, 2)
}
return this
}
type randyCasttype interface {
Float32() float32
Float64() float64
Int63() int64
Int31() int32
Uint32() uint32
Intn(n int) int
}
func <API key>(r randyCasttype) rune {
ru := r.Intn(62)
if ru < 10 {
return rune(ru + 48)
} else if ru < 36 {
return rune(ru + 55)
}
return rune(ru + 61)
}
func randStringCasttype(r randyCasttype) string {
v16 := r.Intn(100)
tmps := make([]rune, v16)
for i := 0; i < v16; i++ {
tmps[i] = <API key>(r)
}
return string(tmps)
}
func <API key>(r randyCasttype, maxFieldNumber int) (dAtA []byte) {
l := r.Intn(5)
for i := 0; i < l; i++ {
wire := r.Intn(4)
if wire == 3 {
wire = 5
}
fieldNumber := maxFieldNumber + r.Intn(100)
dAtA = randFieldCasttype(dAtA, r, fieldNumber, wire)
}
return dAtA
}
func randFieldCasttype(dAtA []byte, r randyCasttype, fieldNumber int, wire int) []byte {
key := uint32(fieldNumber)<<3 | uint32(wire)
switch wire {
case 0:
dAtA = <API key>(dAtA, uint64(key))
v17 := r.Int63()
if r.Intn(2) == 0 {
v17 *= -1
}
dAtA = <API key>(dAtA, uint64(v17))
case 1:
dAtA = <API key>(dAtA, uint64(key))
dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
case 2:
dAtA = <API key>(dAtA, uint64(key))
ll := r.Intn(100)
dAtA = <API key>(dAtA, uint64(ll))
for j := 0; j < ll; j++ {
dAtA = append(dAtA, byte(r.Intn(256)))
}
default:
dAtA = <API key>(dAtA, uint64(key))
dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
}
return dAtA
}
func <API key>(dAtA []byte, v uint64) []byte {
for v >= 1<<7 {
dAtA = append(dAtA, uint8(uint64(v)&0x7f|0x80))
v >>= 7
}
dAtA = append(dAtA, uint8(v))
return dAtA
}
func (m *Castaway) Size() (n int) {
var l int
_ = l
if m.Int32Ptr != nil {
n += 1 + sovCasttype(uint64(*m.Int32Ptr))
}
n += 1 + sovCasttype(uint64(m.Int32))
if m.MyUint64Ptr != nil {
n += 1 + sovCasttype(uint64(*m.MyUint64Ptr))
}
n += 1 + sovCasttype(uint64(m.MyUint64))
if m.MyFloat32Ptr != nil {
n += 5
}
n += 5
if m.MyFloat64Ptr != nil {
n += 9
}
n += 9
if m.MyBytes != nil {
l = len(m.MyBytes)
n += 1 + l + sovCasttype(uint64(l))
}
if m.NormalBytes != nil {
l = len(m.NormalBytes)
n += 1 + l + sovCasttype(uint64(l))
}
if len(m.MyUint64S) > 0 {
for _, e := range m.MyUint64S {
n += 1 + sovCasttype(uint64(e))
}
}
if len(m.MyMap) > 0 {
for k, v := range m.MyMap {
_ = k
_ = v
mapEntrySize := 1 + len(k) + sovCasttype(uint64(len(k))) + 1 + sovCasttype(uint64(v))
n += mapEntrySize + 1 + sovCasttype(uint64(mapEntrySize))
}
}
if len(m.MyCustomMap) > 0 {
for k, v := range m.MyCustomMap {
_ = k
_ = v
mapEntrySize := 1 + len(k) + sovCasttype(uint64(len(k))) + 1 + sovCasttype(uint64(v))
n += mapEntrySize + 1 + sovCasttype(uint64(mapEntrySize))
}
}
if len(m.MyNullableMap) > 0 {
for k, v := range m.MyNullableMap {
_ = k
_ = v
l = 0
if v != nil {
l = v.Size()
l += 1 + sovCasttype(uint64(l))
}
mapEntrySize := 1 + sovCasttype(uint64(k)) + l
n += mapEntrySize + 1 + sovCasttype(uint64(mapEntrySize))
}
}
if len(m.MyEmbeddedMap) > 0 {
for k, v := range m.MyEmbeddedMap {
_ = k
_ = v
l = v.Size()
mapEntrySize := 1 + sovCasttype(uint64(k)) + 1 + l + sovCasttype(uint64(l))
n += mapEntrySize + 1 + sovCasttype(uint64(mapEntrySize))
}
}
if m.String_ != nil {
l = len(*m.String_)
n += 2 + l + sovCasttype(uint64(l))
}
if m.XXX_unrecognized != nil {
n += len(m.XXX_unrecognized)
}
return n
}
func (m *Wilson) Size() (n int) {
var l int
_ = l
if m.Int64 != nil {
n += 1 + sovCasttype(uint64(*m.Int64))
}
if m.XXX_unrecognized != nil {
n += len(m.XXX_unrecognized)
}
return n
}
func sovCasttype(x uint64) (n int) {
for {
n++
x >>= 7
if x == 0 {
break
}
}
return n
}
func sozCasttype(x uint64) (n int) {
return sovCasttype(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (this *Castaway) String() string {
if this == nil {
return "nil"
}
keysForMyMap := make([]string, 0, len(this.MyMap))
for k := range this.MyMap {
keysForMyMap = append(keysForMyMap, k)
}
<API key>.Strings(keysForMyMap)
mapStringForMyMap := "<API key>.MyMapType{"
for _, k := range keysForMyMap {
mapStringForMyMap += fmt.Sprintf("%v: %v,", k, this.MyMap[k])
}
mapStringForMyMap += "}"
keysForMyCustomMap := make([]string, 0, len(this.MyCustomMap))
for k := range this.MyCustomMap {
keysForMyCustomMap = append(keysForMyCustomMap, string(k))
}
<API key>.Strings(keysForMyCustomMap)
<API key> := "map[<API key>.MyStringType]<API key>.MyUint64Type{"
for _, k := range keysForMyCustomMap {
<API key> += fmt.Sprintf("%v: %v,", k, this.MyCustomMap[<API key>.MyStringType(k)])
}
<API key> += "}"
<API key> := make([]int32, 0, len(this.MyNullableMap))
for k := range this.MyNullableMap {
<API key> = append(<API key>, int32(k))
}
<API key>.Int32s(<API key>)
<API key> := "map[<API key>.MyInt32Type]*Wilson{"
for _, k := range <API key> {
<API key> += fmt.Sprintf("%v: %v,", k, this.MyNullableMap[<API key>.MyInt32Type(k)])
}
<API key> += "}"
<API key> := make([]int32, 0, len(this.MyEmbeddedMap))
for k := range this.MyEmbeddedMap {
<API key> = append(<API key>, int32(k))
}
<API key>.Int32s(<API key>)
<API key> := "map[<API key>.MyInt32Type]Wilson{"
for _, k := range <API key> {
<API key> += fmt.Sprintf("%v: %v,", k, this.MyEmbeddedMap[<API key>.MyInt32Type(k)])
}
<API key> += "}"
s := strings.Join([]string{`&Castaway{`,
`Int32Ptr:` + <API key>(this.Int32Ptr) + `,`,
`Int32:` + fmt.Sprintf("%v", this.Int32) + `,`,
`MyUint64Ptr:` + <API key>(this.MyUint64Ptr) + `,`,
`MyUint64:` + fmt.Sprintf("%v", this.MyUint64) + `,`,
`MyFloat32Ptr:` + <API key>(this.MyFloat32Ptr) + `,`,
`MyFloat32:` + fmt.Sprintf("%v", this.MyFloat32) + `,`,
`MyFloat64Ptr:` + <API key>(this.MyFloat64Ptr) + `,`,
`MyFloat64:` + fmt.Sprintf("%v", this.MyFloat64) + `,`,
`MyBytes:` + <API key>(this.MyBytes) + `,`,
`NormalBytes:` + <API key>(this.NormalBytes) + `,`,
`MyUint64S:` + fmt.Sprintf("%v", this.MyUint64S) + `,`,
`MyMap:` + mapStringForMyMap + `,`,
`MyCustomMap:` + <API key> + `,`,
`MyNullableMap:` + <API key> + `,`,
`MyEmbeddedMap:` + <API key> + `,`,
`String_:` + <API key>(this.String_) + `,`,
`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
`}`,
}, "")
return s
}
func (this *Wilson) String() string {
if this == nil {
return "nil"
}
s := strings.Join([]string{`&Wilson{`,
`Int64:` + <API key>(this.Int64) + `,`,
`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
`}`,
}, "")
return s
}
func <API key>(v interface{}) string {
rv := reflect.ValueOf(v)
if rv.IsNil() {
return "nil"
}
pv := reflect.Indirect(rv).Interface()
return fmt.Sprintf("*%v", pv)
}
func (m *Castaway) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *Castaway) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.Int32Ptr != nil {
dAtA[i] = 0x8
i++
i = <API key>(dAtA, i, uint64(*m.Int32Ptr))
}
dAtA[i] = 0x10
i++
i = <API key>(dAtA, i, uint64(m.Int32))
if m.MyUint64Ptr != nil {
dAtA[i] = 0x18
i++
i = <API key>(dAtA, i, uint64(*m.MyUint64Ptr))
}
dAtA[i] = 0x20
i++
i = <API key>(dAtA, i, uint64(m.MyUint64))
if m.MyFloat32Ptr != nil {
dAtA[i] = 0x2d
i++
i = <API key>(dAtA, i, uint32(math.Float32bits(float32(*m.MyFloat32Ptr))))
}
dAtA[i] = 0x35
i++
i = <API key>(dAtA, i, uint32(math.Float32bits(float32(m.MyFloat32))))
if m.MyFloat64Ptr != nil {
dAtA[i] = 0x39
i++
i = <API key>(dAtA, i, uint64(math.Float64bits(float64(*m.MyFloat64Ptr))))
}
dAtA[i] = 0x41
i++
i = <API key>(dAtA, i, uint64(math.Float64bits(float64(m.MyFloat64))))
if m.MyBytes != nil {
dAtA[i] = 0x4a
i++
i = <API key>(dAtA, i, uint64(len(m.MyBytes)))
i += copy(dAtA[i:], m.MyBytes)
}
if m.NormalBytes != nil {
dAtA[i] = 0x52
i++
i = <API key>(dAtA, i, uint64(len(m.NormalBytes)))
i += copy(dAtA[i:], m.NormalBytes)
}
if len(m.MyUint64S) > 0 {
for _, num := range m.MyUint64S {
dAtA[i] = 0x58
i++
i = <API key>(dAtA, i, uint64(num))
}
}
if len(m.MyMap) > 0 {
for k := range m.MyMap {
dAtA[i] = 0x62
i++
v := m.MyMap[k]
mapSize := 1 + len(k) + sovCasttype(uint64(len(k))) + 1 + sovCasttype(uint64(v))
i = <API key>(dAtA, i, uint64(mapSize))
dAtA[i] = 0xa
i++
i = <API key>(dAtA, i, uint64(len(k)))
i += copy(dAtA[i:], k)
dAtA[i] = 0x10
i++
i = <API key>(dAtA, i, uint64(v))
}
}
if len(m.MyCustomMap) > 0 {
for k := range m.MyCustomMap {
dAtA[i] = 0x6a
i++
v := m.MyCustomMap[k]
mapSize := 1 + len(k) + sovCasttype(uint64(len(k))) + 1 + sovCasttype(uint64(v))
i = <API key>(dAtA, i, uint64(mapSize))
dAtA[i] = 0xa
i++
i = <API key>(dAtA, i, uint64(len(k)))
i += copy(dAtA[i:], k)
dAtA[i] = 0x10
i++
i = <API key>(dAtA, i, uint64(v))
}
}
if len(m.MyNullableMap) > 0 {
for k := range m.MyNullableMap {
dAtA[i] = 0x72
i++
v := m.MyNullableMap[k]
msgSize := 0
if v != nil {
msgSize = v.Size()
msgSize += 1 + sovCasttype(uint64(msgSize))
}
mapSize := 1 + sovCasttype(uint64(k)) + msgSize
i = <API key>(dAtA, i, uint64(mapSize))
dAtA[i] = 0x8
i++
i = <API key>(dAtA, i, uint64(k))
if v != nil {
dAtA[i] = 0x12
i++
i = <API key>(dAtA, i, uint64(v.Size()))
n1, err := v.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n1
}
}
}
if len(m.MyEmbeddedMap) > 0 {
for k := range m.MyEmbeddedMap {
dAtA[i] = 0x7a
i++
v := m.MyEmbeddedMap[k]
msgSize := 0
if (&v) != nil {
msgSize = (&v).Size()
msgSize += 1 + sovCasttype(uint64(msgSize))
}
mapSize := 1 + sovCasttype(uint64(k)) + msgSize
i = <API key>(dAtA, i, uint64(mapSize))
dAtA[i] = 0x8
i++
i = <API key>(dAtA, i, uint64(k))
dAtA[i] = 0x12
i++
i = <API key>(dAtA, i, uint64((&v).Size()))
n2, err := (&v).MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n2
}
}
if m.String_ != nil {
dAtA[i] = 0x82
i++
dAtA[i] = 0x1
i++
i = <API key>(dAtA, i, uint64(len(*m.String_)))
i += copy(dAtA[i:], *m.String_)
}
if m.XXX_unrecognized != nil {
i += copy(dAtA[i:], m.XXX_unrecognized)
}
return i, nil
}
func (m *Wilson) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *Wilson) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.Int64 != nil {
dAtA[i] = 0x8
i++
i = <API key>(dAtA, i, uint64(*m.Int64))
}
if m.XXX_unrecognized != nil {
i += copy(dAtA[i:], m.XXX_unrecognized)
}
return i, nil
}
func <API key>(dAtA []byte, offset int, v uint64) int {
dAtA[offset] = uint8(v)
dAtA[offset+1] = uint8(v >> 8)
dAtA[offset+2] = uint8(v >> 16)
dAtA[offset+3] = uint8(v >> 24)
dAtA[offset+4] = uint8(v >> 32)
dAtA[offset+5] = uint8(v >> 40)
dAtA[offset+6] = uint8(v >> 48)
dAtA[offset+7] = uint8(v >> 56)
return offset + 8
}
func <API key>(dAtA []byte, offset int, v uint32) int {
dAtA[offset] = uint8(v)
dAtA[offset+1] = uint8(v >> 8)
dAtA[offset+2] = uint8(v >> 16)
dAtA[offset+3] = uint8(v >> 24)
return offset + 4
}
func <API key>(dAtA []byte, offset int, v uint64) int {
for v >= 1<<7 {
dAtA[offset] = uint8(v&0x7f | 0x80)
v >>= 7
offset++
}
dAtA[offset] = uint8(v)
return offset + 1
}
func init() { proto.RegisterFile("combos/unsafemarshaler/casttype.proto", <API key>) }
var <API key> = []byte{
// 701 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xa4, 0x95, 0xbf, 0x6f, 0xd3, 0x40,
0x14, 0xc7, 0x7d, 0x4d, 0xd3, 0x26, 0x97, 0x06, 0xa2, 0x13, 0x83, 0x55, 0x89, 0xb3, 0xd5, 0xaa,
0xc8, 0x03, 0x24, 0x55, 0x1a, 0x95, 0xaa, 0x20, 0x06, 0x57, 0x45, 0x2a, 0xc2, 0x05, 0x19, 0xaa,
0x0a, 0xc4, 0x72, 0x69, 0xdd, 0x34, 0xc2, 0xb1, 0x23, 0xfb, 0x02, 0xf2, 0x56, 0x95, 0x01, 0x89,
0xbf, 0x84, 0x91, 0x05, 0x89, 0x91, 0xb1, 0x63, 0x47, 0xa6, 0xb4, 0x36, 0x4b, 0xd9, 0x3a, 0x56,
0x99, 0xd0, 0xdd, 0x39, 0xb1, 0xfb, 0x03, 0x94, 0xa6, 0xdb, 0xbd, 0xbb, 0xf7, 0x3e, 0xef, 0x7b,
0xef, 0xde, 0xdd, 0xc1, 0xb9, 0x2d, 0xb7, 0x55, 0x77, 0xfd, 0x4a, 0xc7, 0xf1, 0xc9, 0x8e, 0xd5,
0x22, 0x9e, 0xbf, 0x4b, 0x6c, 0xcb, 0xab, 0x6c, 0x11, 0x9f, 0xd2, 0xa0, 0x6d, 0x95, 0xdb, 0x9e,
0x4b, 0x5d, 0x94, 0xeb, 0xdb, 0xd3, 0x0f, 0x1a, 0x4d, 0xba, 0xdb, 0xa9, 0x97, 0xb7, 0xdc, 0x56,
0xa5, 0xe1, 0x36, 0xdc, 0x0a, 0x77, 0xa8, 0x77, 0x76, 0xb8, 0xc5, 0x0d, 0x3e, 0x12, 0x81, 0x33,
0x7f, 0x8a, 0x30, 0xb7, 0x42, 0x7c, 0x4a, 0x3e, 0x92, 0x00, 0xcd, 0xc1, 0xdc, 0x9a, 0x43, 0x17,
0xaa, 0x2f, 0xa9, 0x27, 0x03, 0x15, 0x68, 0x19, 0x3d, 0xdf, 0xeb, 0x2a, 0xd9, 0x26, 0x9b, 0x33,
0x07, 0x4b, 0x68, 0x16, 0x66, 0xf9, 0x58, 0x1e, 0xe3, 0x3e, 0xc5, 0x83, 0xae, 0x22, 0x25, 0x7e,
0x62, 0x0d, 0xbd, 0x81, 0x05, 0x23, 0xd8, 0x68, 0x3a, 0x74, 0xb1, 0xc6, 0x70, 0x19, 0x15, 0x68,
0xe3, 0xfa, 0xc3, 0x5e, 0x57, 0x59, 0xf8, 0xa7, 0x40, 0x6a, 0xf9, 0x34, 0xd9, 0x58, 0x3f, 0xfa,
0x75, 0xd0, 0xb6, 0xcc, 0x34, 0x0b, 0x6d, 0xc2, 0x5c, 0xdf, 0x94, 0xc7, 0x39, 0xf7, 0x51, 0x2c,
0x61, 0x24, 0xf6, 0x00, 0x86, 0xde, 0xc1, 0x29, 0x23, 0x78, 0x6a, 0xbb, 0x24, 0xae, 0x41, 0x56,
0x05, 0xda, 0x98, 0xbe, 0xd4, 0xeb, 0x2a, 0xb5, 0xa1, 0xc1, 0x71, 0x38, 0x27, 0x9f, 0xa3, 0xa1,
0xb7, 0x30, 0x3f, 0xb0, 0xe5, 0x09, 0x8e, 0x7e, 0x1c, 0xeb, 0x1e, 0x0d, 0x9f, 0xe0, 0x52, 0xca,
0x45, 0xb9, 0x27, 0x55, 0xa0, 0x81, 0x51, 0x94, 0xc7, 0x35, 0x39, 0x47, 0x4b, 0x29, 0x5f, 0xac,
0xc9, 0x39, 0x8e, 0x1e, 0x51, 0x79, 0x8c, 0x4f, 0x70, 0xe8, 0x19, 0x9c, 0x34, 0x02, 0x3d, 0xa0,
0x96, 0x2f, 0xe7, 0x55, 0xa0, 0x4d, 0xe9, 0xf3, 0xbd, 0xae, 0x72, 0x7f, 0x48, 0x2a, 0x8f, 0x33,
0xfb, 0x00, 0xa4, 0xc2, 0xc2, 0xba, 0xeb, 0xb5, 0x88, 0x2d, 0x78, 0x90, 0xf1, 0xcc, 0xf4, 0x14,
0xda, 0x60, 0x3b, 0x11, 0xa7, 0xed, 0xcb, 0x05, 0x35, 0x73, 0x93, 0x9e, 0x4c, 0x48, 0xa8, 0x09,
0xb3, 0x46, 0x60, 0x90, 0xb6, 0x3c, 0xa5, 0x66, 0xb4, 0x42, 0xf5, 0x6e, 0x79, 0x10, 0xd1, 0xbf,
0x5b, 0x65, 0xbe, 0xbe, 0xea, 0x50, 0x2f, 0xd0, 0x6b, 0xbd, 0xae, 0x32, 0x3f, 0x74, 0x46, 0x83,
0xb4, 0x79, 0x3a, 0x91, 0x01, 0x7d, 0x07, 0xec, 0x62, 0xad, 0x74, 0x7c, 0xea, 0xb6, 0x58, 0xc6,
0x22, 0xcf, 0x38, 0x7b, 0x65, 0xc6, 0x81, 0x97, 0xc8, 0xeb, 0xec, 0x1f, 0x5d, 0x63, 0xa7, 0xaf,
0xa8, 0xd7, 0x74, 0x1a, 0x2c, 0xf5, 0x97, 0xa3, 0x91, 0x2f, 0xed, 0x40, 0x01, 0xfa, 0x04, 0x60,
0xd1, 0x08, 0xd6, 0x3b, 0xb6, 0x4d, 0xea, 0xb6, 0xc5, 0x94, 0xdf, 0xe2, 0xca, 0xe7, 0xae, 0x54,
0x9e, 0xf2, 0x13, 0xda, 0x17, 0xf7, 0x8f, 0x94, 0xea, 0xd0, 0x22, 0xf8, 0x13, 0xc4, 0x35, 0x9c,
0xcf, 0x89, 0x3e, 0x73, 0x15, 0xab, 0xad, 0xba, 0xb5, 0xbd, 0x6d, 0x6d, 0x33, 0x15, 0xb7, 0xff,
0xa3, 0x22, 0xe5, 0x27, 0x54, 0x2c, 0xb3, 0xae, 0x1f, 0x5d, 0x49, 0x8a, 0x87, 0x5e, 0xc0, 0x09,
0x51, 0x61, 0xb9, 0xa4, 0x02, 0x2d, 0x7f, 0xcd, 0x36, 0x4c, 0x0e, 0xc7, 0x8c, 0x31, 0xd3, 0x4b,
0x10, 0x26, 0x3d, 0x86, 0x4a, 0x30, 0xf3, 0xde, 0x0a, 0xf8, 0x2b, 0x9e, 0x37, 0xd9, 0x10, 0xdd,
0x81, 0xd9, 0x0f, 0xc4, 0xee, 0x58, 0xfc, 0xd5, 0x1e, 0x37, 0x85, 0xb1, 0x3c, 0xb6, 0x04, 0xa6,
0x9f, 0xc0, 0xd2, 0xc5, 0x5e, 0xb9, 0x56, 0xbc, 0x09, 0xd1, 0xe5, 0x13, 0x4b, 0x13, 0xb2, 0x82,
0x70, 0x2f, 0x4d, 0x28, 0x54, 0x4b, 0x49, 0xcd, 0x37, 0x9b, 0xb6, 0xef, 0x3a, 0x97, 0x98, 0x17,
0xeb, 0x7f, 0x33, 0xe6, 0x0c, 0x86, 0x13, 0x62, 0x92, 0xed, 0x65, 0x8d, 0x7f, 0x1f, 0xfc, 0x97,
0x33, 0x85, 0xa1, 0x3f, 0x3f, 0x08, 0xb1, 0x74, 0x18, 0x62, 0xe9, 0x57, 0x88, 0xa5, 0xe3, 0x10,
0x83, 0x93, 0x10, 0x83, 0xd3, 0x10, 0x83, 0xb3, 0x10, 0x83, 0xbd, 0x08, 0x83, 0xaf, 0x11, 0x06,
0xdf, 0x22, 0x0c, 0x7e, 0x44, 0x18, 0xfc, 0x8c, 0x30, 0x38, 0x88, 0xb0, 0x74, 0x18, 0x61, 0xe9,
0x38, 0xc2, 0xe0, 0x24, 0xc2, 0xd2, 0x69, 0x84, 0xc1, 0x59, 0x84, 0xc1, 0xde, 0x6f, 0x2c, 0xfd,
0x0d, 0x00, 0x00, 0xff, 0xff, 0xd8, 0x47, 0x3b, 0xeb, 0xba, 0x07, 0x00, 0x00,
}
|
package ru.job4j.polymorphism;
public class StubInput implements Input {
/**
* @param answers - array's param.
*/
private String[] answers;
/**
* @param position - param count position.
*/
private int position = 0;
/**
* Constructor.
* @param answers - array's param.
*/
public StubInput(String[] answers) {
this.answers = answers;
}
/**
* Method from interface.
* @param question - param of method interface.
* @return - string.
*/
public String ask(String question) {
return answers[position++];
}
}
|
<html dir="LTR">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=Windows-1252" />
<meta name="vs_targetSchema" content="http://schemas.microsoft.com/intellisense/ie5" />
<title>StringMatchFilter.<API key> Field</title>
<xml>
</xml>
<link rel="stylesheet" type="text/css" href="MSDN.css" />
</head>
<body id="bodyID" class="dtBODY">
<div id="nsbanner">
<div id="bannerrow1">
<table class="bannerparthead" cellspacing="0">
<tr id="hdr">
<td class="runninghead">log4net SDK Reference</td>
<td class="product">
</td>
</tr>
</table>
</div>
<div id="TitleRow">
<h1 class="dtH1">StringMatchFilter.<API key> Field
</h1>
</div>
</div>
<div id="nstext">
<p> A string regex to match </p>
<div class="syntax">
<span class="lang">[Visual Basic]</span>
<br />Protected <API key> As <a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/<API key>.asp">String</a></div>
<div class="syntax">
<span class="lang">[C#]</span>
<br />protected <a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/<API key>.asp">string</a> <API key>;</div>
<p>
</p>
<h4 class="dtH4">Remarks</h4>
<p>
<span class="missing">Missing <remarks> documentation for F:log4net.Filter.StringMatchFilter.<API key></span>
</p>
<h4 class="dtH4">See Also</h4>
<p>
<a href="log4net.Filter.StringMatchFilter.html">StringMatchFilter Class</a> | <a href="log4net.Filter.html">log4net.Filter Namespace</a></p>
<hr />
<div id="footer">
<p>
<a href="http:
</p>
<p>Generated from assembly log4net [1.2.10.0]</p>
</div>
</div>
</body>
</html>
|
import { Component } from '@angular/core';
@Component({
selector: '<API key>',
template: '<ng-content></ng-content>',
styles: [':host { display: block; }'],
host: {
'class': 'row'
}
})
export class <API key> {
}
|
<!DOCTYPE HTML PUBLIC "-
<!-- NewPage -->
<html lang="en">
<head>
<!-- Generated by javadoc (1.8.0_151) on Wed Jul 17 13:50:51 MST 2019 -->
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Uses of Interface org.wildfly.swarm.config.infinispan.cache_container.<API key> (BOM: * : All 2.5.0.Final API)</title>
<meta name="date" content="2019-07-17">
<link rel="stylesheet" type="text/css" href="../../../../../../../stylesheet.css" title="Style">
<script type="text/javascript" src="../../../../../../../script.js"></script>
</head>
<body>
<script type="text/javascript"><!
try {
if (location.href.indexOf('is-external=true') == -1) {
parent.document.title="Uses of Interface org.wildfly.swarm.config.infinispan.cache_container.<API key> (BOM: * : All 2.5.0.Final API)";
}
}
catch(err) {
}
</script>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
<div class="topNav"><a name="navbar.top">
</a>
<div class="skipNav"><a href="#skip.navbar.top" title="Skip navigation links">Skip navigation links</a></div>
<a name="navbar.top.firstrow">
</a>
<ul class="navList" title="Navigation">
<li><a href="../../../../../../../overview-summary.html">Overview</a></li>
<li><a href="../package-summary.html">Package</a></li>
<li><a href="../../../../../../../org/wildfly/swarm/config/infinispan/cache_container/<API key>.html" title="interface in org.wildfly.swarm.config.infinispan.cache_container">Class</a></li>
<li class="navBarCell1Rev">Use</li>
<li><a href="../../../../../../../overview-tree.html">Tree</a></li>
<li><a href="../../../../../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../../../../../index-all.html">Index</a></li>
<li><a href="../../../../../../../help-doc.html">Help</a></li>
</ul>
<div class="aboutLanguage">Thorntail API, 2.5.0.Final</div>
</div>
<div class="subNav">
<ul class="navList">
<li>Prev</li>
<li>Next</li>
</ul>
<ul class="navList">
<li><a href="../../../../../../../index.html?org/wildfly/swarm/config/infinispan/cache_container/class-use/<API key>.html" target="_top">Frames</a></li>
<li><a href="<API key>.html" target="_top">No Frames</a></li>
</ul>
<ul class="navList" id="<API key>">
<li><a href="../../../../../../../allclasses-noframe.html">All Classes</a></li>
</ul>
<div>
<script type="text/javascript"><!
allClassesLink = document.getElementById("<API key>");
if(window==top) {
allClassesLink.style.display = "block";
}
else {
allClassesLink.style.display = "none";
}
</script>
</div>
<a name="skip.navbar.top">
</a></div>
<div class="header">
<h2 title="Uses of Interface org.wildfly.swarm.config.infinispan.cache_container.<API key>" class="title">Uses of Interface<br>org.wildfly.swarm.config.infinispan.cache_container.<API key></h2>
</div>
<div class="classUseContainer">
<ul class="blockList">
<li class="blockList">
<table class="useSummary" border="0" cellpadding="3" cellspacing="0" summary="Use table, listing packages, and an explanation">
<caption><span>Packages that use <a href="../../../../../../../org/wildfly/swarm/config/infinispan/cache_container/<API key>.html" title="interface in org.wildfly.swarm.config.infinispan.cache_container"><API key></a></span><span class="tabEnd"> </span></caption>
<tr>
<th class="colFirst" scope="col">Package</th>
<th class="colLast" scope="col">Description</th>
</tr>
<tbody>
<tr class="altColor">
<td class="colFirst"><a href="#org.wildfly.swarm.config.infinispan.cache_container">org.wildfly.swarm.config.infinispan.cache_container</a></td>
<td class="colLast"> </td>
</tr>
</tbody>
</table>
</li>
<li class="blockList">
<ul class="blockList">
<li class="blockList"><a name="org.wildfly.swarm.config.infinispan.cache_container">
</a>
<h3>Uses of <a href="../../../../../../../org/wildfly/swarm/config/infinispan/cache_container/<API key>.html" title="interface in org.wildfly.swarm.config.infinispan.cache_container"><API key></a> in <a href="../../../../../../../org/wildfly/swarm/config/infinispan/cache_container/package-summary.html">org.wildfly.swarm.config.infinispan.cache_container</a></h3>
<table class="useSummary" border="0" cellpadding="3" cellspacing="0" summary="Use table, listing methods, and an explanation">
<caption><span>Methods in <a href="../../../../../../../org/wildfly/swarm/config/infinispan/cache_container/package-summary.html">org.wildfly.swarm.config.infinispan.cache_container</a> that return <a href="../../../../../../../org/wildfly/swarm/config/infinispan/cache_container/<API key>.html" title="interface in org.wildfly.swarm.config.infinispan.cache_container"><API key></a></span><span class="tabEnd"> </span></caption>
<tr>
<th class="colFirst" scope="col">Modifier and Type</th>
<th class="colLast" scope="col">Method and Description</th>
</tr>
<tbody>
<tr class="altColor">
<td class="colFirst"><code>default <a href="../../../../../../../org/wildfly/swarm/config/infinispan/cache_container/<API key>.html" title="interface in org.wildfly.swarm.config.infinispan.cache_container"><API key></a><<a href="../../../../../../../org/wildfly/swarm/config/infinispan/cache_container/<API key>.html" title="type parameter in <API key>">T</a>></code></td>
<td class="colLast"><span class="typeNameLabel"><API key>.</span><code><span class="memberNameLink"><a href="../../../../../../../org/wildfly/swarm/config/infinispan/cache_container/<API key>.html#andThen-org.wildfly.swarm.config.infinispan.cache_container.<API key>-">andThen</a></span>(<a href="../../../../../../../org/wildfly/swarm/config/infinispan/cache_container/<API key>.html" title="interface in org.wildfly.swarm.config.infinispan.cache_container"><API key></a><<a href="../../../../../../../org/wildfly/swarm/config/infinispan/cache_container/<API key>.html" title="type parameter in <API key>">T</a>> after)</code> </td>
</tr>
</tbody>
</table>
<table class="useSummary" border="0" cellpadding="3" cellspacing="0" summary="Use table, listing methods, and an explanation">
<caption><span>Methods in <a href="../../../../../../../org/wildfly/swarm/config/infinispan/cache_container/package-summary.html">org.wildfly.swarm.config.infinispan.cache_container</a> with parameters of type <a href="../../../../../../../org/wildfly/swarm/config/infinispan/cache_container/<API key>.html" title="interface in org.wildfly.swarm.config.infinispan.cache_container"><API key></a></span><span class="tabEnd"> </span></caption>
<tr>
<th class="colFirst" scope="col">Modifier and Type</th>
<th class="colLast" scope="col">Method and Description</th>
</tr>
<tbody>
<tr class="altColor">
<td class="colFirst"><code>default <a href="../../../../../../../org/wildfly/swarm/config/infinispan/cache_container/<API key>.html" title="interface in org.wildfly.swarm.config.infinispan.cache_container"><API key></a><<a href="../../../../../../../org/wildfly/swarm/config/infinispan/cache_container/<API key>.html" title="type parameter in <API key>">T</a>></code></td>
<td class="colLast"><span class="typeNameLabel"><API key>.</span><code><span class="memberNameLink"><a href="../../../../../../../org/wildfly/swarm/config/infinispan/cache_container/<API key>.html#andThen-org.wildfly.swarm.config.infinispan.cache_container.<API key>-">andThen</a></span>(<a href="../../../../../../../org/wildfly/swarm/config/infinispan/cache_container/<API key>.html" title="interface in org.wildfly.swarm.config.infinispan.cache_container"><API key></a><<a href="../../../../../../../org/wildfly/swarm/config/infinispan/cache_container/<API key>.html" title="type parameter in <API key>">T</a>> after)</code> </td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code><a href="../../../../../../../org/wildfly/swarm/config/infinispan/cache_container/ScatteredCache.html" title="type parameter in ScatteredCache">T</a></code></td>
<td class="colLast"><span class="typeNameLabel">ScatteredCache.</span><code><span class="memberNameLink"><a href="../../../../../../../org/wildfly/swarm/config/infinispan/cache_container/ScatteredCache.html#<API key>.wildfly.swarm.config.infinispan.cache_container.<API key>-">backupForComponent</a></span>(<a href="../../../../../../../org/wildfly/swarm/config/infinispan/cache_container/<API key>.html" title="interface in org.wildfly.swarm.config.infinispan.cache_container"><API key></a> consumer)</code>
<div class="block">A cache for which this cache acts as a backup (for use with cross site
replication).</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code><a href="../../../../../../../org/wildfly/swarm/config/infinispan/cache_container/DistributedCache.html" title="type parameter in DistributedCache">T</a></code></td>
<td class="colLast"><span class="typeNameLabel">DistributedCache.</span><code><span class="memberNameLink"><a href="../../../../../../../org/wildfly/swarm/config/infinispan/cache_container/DistributedCache.html#<API key>.wildfly.swarm.config.infinispan.cache_container.<API key>-">backupForComponent</a></span>(<a href="../../../../../../../org/wildfly/swarm/config/infinispan/cache_container/<API key>.html" title="interface in org.wildfly.swarm.config.infinispan.cache_container"><API key></a> consumer)</code>
<div class="block">A cache for which this cache acts as a backup (for use with cross site
replication).</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code><a href="../../../../../../../org/wildfly/swarm/config/infinispan/cache_container/ReplicatedCache.html" title="type parameter in ReplicatedCache">T</a></code></td>
<td class="colLast"><span class="typeNameLabel">ReplicatedCache.</span><code><span class="memberNameLink"><a href="../../../../../../../org/wildfly/swarm/config/infinispan/cache_container/ReplicatedCache.html#<API key>.wildfly.swarm.config.infinispan.cache_container.<API key>-">backupForComponent</a></span>(<a href="../../../../../../../org/wildfly/swarm/config/infinispan/cache_container/<API key>.html" title="interface in org.wildfly.swarm.config.infinispan.cache_container"><API key></a> consumer)</code>
<div class="block">A cache for which this cache acts as a backup (for use with cross site
replication).</div>
</td>
</tr>
</tbody>
</table>
</li>
</ul>
</li>
</ul>
</div>
<div class="bottomNav"><a name="navbar.bottom">
</a>
<div class="skipNav"><a href="#skip.navbar.bottom" title="Skip navigation links">Skip navigation links</a></div>
<a name="navbar.bottom.firstrow">
</a>
<ul class="navList" title="Navigation">
<li><a href="../../../../../../../overview-summary.html">Overview</a></li>
<li><a href="../package-summary.html">Package</a></li>
<li><a href="../../../../../../../org/wildfly/swarm/config/infinispan/cache_container/<API key>.html" title="interface in org.wildfly.swarm.config.infinispan.cache_container">Class</a></li>
<li class="navBarCell1Rev">Use</li>
<li><a href="../../../../../../../overview-tree.html">Tree</a></li>
<li><a href="../../../../../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../../../../../index-all.html">Index</a></li>
<li><a href="../../../../../../../help-doc.html">Help</a></li>
</ul>
<div class="aboutLanguage">Thorntail API, 2.5.0.Final</div>
</div>
<div class="subNav">
<ul class="navList">
<li>Prev</li>
<li>Next</li>
</ul>
<ul class="navList">
<li><a href="../../../../../../../index.html?org/wildfly/swarm/config/infinispan/cache_container/class-use/<API key>.html" target="_top">Frames</a></li>
<li><a href="<API key>.html" target="_top">No Frames</a></li>
</ul>
<ul class="navList" id="<API key>">
<li><a href="../../../../../../../allclasses-noframe.html">All Classes</a></li>
</ul>
<div>
<script type="text/javascript"><!
allClassesLink = document.getElementById("<API key>");
if(window==top) {
allClassesLink.style.display = "block";
}
else {
allClassesLink.style.display = "none";
}
</script>
</div>
<a name="skip.navbar.bottom">
</a></div>
<p class="legalCopy"><small>Copyright &
</body>
</html>
|
<!DOCTYPE HTML PUBLIC "-
<!-- NewPage -->
<html lang="en">
<head>
<!-- Generated by javadoc (1.8.0_60-ea) on Wed Jan 04 17:08:18 EST 2017 -->
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Uses of Interface org.wildfly.swarm.config.NamingConsumer (Public javadocs 2017.1.1 API)</title>
<meta name="date" content="2017-01-04">
<link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
<script type="text/javascript" src="../../../../../script.js"></script>
</head>
<body>
<script type="text/javascript"><!
try {
if (location.href.indexOf('is-external=true') == -1) {
parent.document.title="Uses of Interface org.wildfly.swarm.config.NamingConsumer (Public javadocs 2017.1.1 API)";
}
}
catch(err) {
}
</script>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
<div class="topNav"><a name="navbar.top">
</a>
<div class="skipNav"><a href="#skip.navbar.top" title="Skip navigation links">Skip navigation links</a></div>
<a name="navbar.top.firstrow">
</a>
<ul class="navList" title="Navigation">
<li><a href="../../../../../overview-summary.html">Overview</a></li>
<li><a href="../package-summary.html">Package</a></li>
<li><a href="../../../../../org/wildfly/swarm/config/NamingConsumer.html" title="interface in org.wildfly.swarm.config">Class</a></li>
<li class="navBarCell1Rev">Use</li>
<li><a href="../../../../../overview-tree.html">Tree</a></li>
<li><a href="../../../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../../../index-all.html">Index</a></li>
<li><a href="../../../../../help-doc.html">Help</a></li>
</ul>
<div class="aboutLanguage">WildFly Swarm API, 2017.1.1</div>
</div>
<div class="subNav">
<ul class="navList">
<li>Prev</li>
<li>Next</li>
</ul>
<ul class="navList">
<li><a href="../../../../../index.html?org/wildfly/swarm/config/class-use/NamingConsumer.html" target="_top">Frames</a></li>
<li><a href="NamingConsumer.html" target="_top">No Frames</a></li>
</ul>
<ul class="navList" id="<API key>">
<li><a href="../../../../../allclasses-noframe.html">All Classes</a></li>
</ul>
<div>
<script type="text/javascript"><!
allClassesLink = document.getElementById("<API key>");
if(window==top) {
allClassesLink.style.display = "block";
}
else {
allClassesLink.style.display = "none";
}
</script>
</div>
<a name="skip.navbar.top">
</a></div>
<div class="header">
<h2 title="Uses of Interface org.wildfly.swarm.config.NamingConsumer" class="title">Uses of Interface<br>org.wildfly.swarm.config.NamingConsumer</h2>
</div>
<div class="classUseContainer">
<ul class="blockList">
<li class="blockList">
<table class="useSummary" border="0" cellpadding="3" cellspacing="0" summary="Use table, listing packages, and an explanation">
<caption><span>Packages that use <a href="../../../../../org/wildfly/swarm/config/NamingConsumer.html" title="interface in org.wildfly.swarm.config">NamingConsumer</a></span><span class="tabEnd"> </span></caption>
<tr>
<th class="colFirst" scope="col">Package</th>
<th class="colLast" scope="col">Description</th>
</tr>
<tbody>
<tr class="altColor">
<td class="colFirst"><a href="#org.wildfly.swarm.config">org.wildfly.swarm.config</a></td>
<td class="colLast"> </td>
</tr>
</tbody>
</table>
</li>
<li class="blockList">
<ul class="blockList">
<li class="blockList"><a name="org.wildfly.swarm.config">
</a>
<h3>Uses of <a href="../../../../../org/wildfly/swarm/config/NamingConsumer.html" title="interface in org.wildfly.swarm.config">NamingConsumer</a> in <a href="../../../../../org/wildfly/swarm/config/package-summary.html">org.wildfly.swarm.config</a></h3>
<table class="useSummary" border="0" cellpadding="3" cellspacing="0" summary="Use table, listing methods, and an explanation">
<caption><span>Methods in <a href="../../../../../org/wildfly/swarm/config/package-summary.html">org.wildfly.swarm.config</a> that return <a href="../../../../../org/wildfly/swarm/config/NamingConsumer.html" title="interface in org.wildfly.swarm.config">NamingConsumer</a></span><span class="tabEnd"> </span></caption>
<tr>
<th class="colFirst" scope="col">Modifier and Type</th>
<th class="colLast" scope="col">Method and Description</th>
</tr>
<tbody>
<tr class="altColor">
<td class="colFirst"><code>default <a href="../../../../../org/wildfly/swarm/config/NamingConsumer.html" title="interface in org.wildfly.swarm.config">NamingConsumer</a><<a href="../../../../../org/wildfly/swarm/config/NamingConsumer.html" title="type parameter in NamingConsumer">T</a>></code></td>
<td class="colLast"><span class="typeNameLabel">NamingConsumer.</span><code><span class="memberNameLink"><a href="../../../../../org/wildfly/swarm/config/NamingConsumer.html#andThen-org.wildfly.swarm.config.NamingConsumer-">andThen</a></span>(<a href="../../../../../org/wildfly/swarm/config/NamingConsumer.html" title="interface in org.wildfly.swarm.config">NamingConsumer</a><<a href="../../../../../org/wildfly/swarm/config/NamingConsumer.html" title="type parameter in NamingConsumer">T</a>> after)</code> </td>
</tr>
</tbody>
</table>
<table class="useSummary" border="0" cellpadding="3" cellspacing="0" summary="Use table, listing methods, and an explanation">
<caption><span>Methods in <a href="../../../../../org/wildfly/swarm/config/package-summary.html">org.wildfly.swarm.config</a> with parameters of type <a href="../../../../../org/wildfly/swarm/config/NamingConsumer.html" title="interface in org.wildfly.swarm.config">NamingConsumer</a></span><span class="tabEnd"> </span></caption>
<tr>
<th class="colFirst" scope="col">Modifier and Type</th>
<th class="colLast" scope="col">Method and Description</th>
</tr>
<tbody>
<tr class="altColor">
<td class="colFirst"><code>default <a href="../../../../../org/wildfly/swarm/config/NamingConsumer.html" title="interface in org.wildfly.swarm.config">NamingConsumer</a><<a href="../../../../../org/wildfly/swarm/config/NamingConsumer.html" title="type parameter in NamingConsumer">T</a>></code></td>
<td class="colLast"><span class="typeNameLabel">NamingConsumer.</span><code><span class="memberNameLink"><a href="../../../../../org/wildfly/swarm/config/NamingConsumer.html#andThen-org.wildfly.swarm.config.NamingConsumer-">andThen</a></span>(<a href="../../../../../org/wildfly/swarm/config/NamingConsumer.html" title="interface in org.wildfly.swarm.config">NamingConsumer</a><<a href="../../../../../org/wildfly/swarm/config/NamingConsumer.html" title="type parameter in NamingConsumer">T</a>> after)</code> </td>
</tr>
</tbody>
</table>
</li>
</ul>
</li>
</ul>
</div>
<div class="bottomNav"><a name="navbar.bottom">
</a>
<div class="skipNav"><a href="#skip.navbar.bottom" title="Skip navigation links">Skip navigation links</a></div>
<a name="navbar.bottom.firstrow">
</a>
<ul class="navList" title="Navigation">
<li><a href="../../../../../overview-summary.html">Overview</a></li>
<li><a href="../package-summary.html">Package</a></li>
<li><a href="../../../../../org/wildfly/swarm/config/NamingConsumer.html" title="interface in org.wildfly.swarm.config">Class</a></li>
<li class="navBarCell1Rev">Use</li>
<li><a href="../../../../../overview-tree.html">Tree</a></li>
<li><a href="../../../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../../../index-all.html">Index</a></li>
<li><a href="../../../../../help-doc.html">Help</a></li>
</ul>
<div class="aboutLanguage">WildFly Swarm API, 2017.1.1</div>
</div>
<div class="subNav">
<ul class="navList">
<li>Prev</li>
<li>Next</li>
</ul>
<ul class="navList">
<li><a href="../../../../../index.html?org/wildfly/swarm/config/class-use/NamingConsumer.html" target="_top">Frames</a></li>
<li><a href="NamingConsumer.html" target="_top">No Frames</a></li>
</ul>
<ul class="navList" id="<API key>">
<li><a href="../../../../../allclasses-noframe.html">All Classes</a></li>
</ul>
<div>
<script type="text/javascript"><!
allClassesLink = document.getElementById("<API key>");
if(window==top) {
allClassesLink.style.display = "block";
}
else {
allClassesLink.style.display = "none";
}
</script>
</div>
<a name="skip.navbar.bottom">
</a></div>
<p class="legalCopy"><small>Copyright &
</body>
</html>
|
// Use of this source code is governed by a BSD-style
// Package odnoklassniki provides constants for using OAuth2 to access Odnoklassniki.
package odnoklassniki
import (
"github.com/coreos/mantle/Godeps/_workspace/src/golang.org/x/oauth2"
)
// Endpoint is Odnoklassniki's OAuth 2.0 endpoint.
var Endpoint = oauth2.Endpoint{
AuthURL: "https:
TokenURL: "https://api.odnoklassniki.ru/oauth/token.do",
}
|
#include "../ohbot.h"
#include "stats.h"
// CStats
CStats :: CStats( CBaseGame *nGame ) : m_Game( nGame ), m_Locked( false )
{
}
CStats :: ~CStats( )
{
}
bool CStats :: ProcessAction( CIncomingAction *Action )
{
return false;
}
void CStats :: Save( COHBot *GHost, COHBotDB *DB, uint32_t GameID )
{
}
|
package org.techniche.technothlon.katana.tcd;
import android.content.Context;
import android.content.SharedPreferences;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.os.AsyncTask;
import android.os.Looper;
import android.util.Log;
import android.widget.TextView;
import android.widget.Toast;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import org.techniche.technothlon.katana.R;
import org.techniche.technothlon.katana.db.TCDDatabase;
import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
public class TCDContent {
/**
* An array of sample (dummy) items.
*/
public static List<TCDQuestionMini> ITEMS = new ArrayList<TCDQuestionMini>();
/**
* A map of sample (dummy) items, by ID.
*/
public static Map<String, TCDQuestion> ITEM_MAP = new HashMap<String, TCDQuestion>();
private static String url = "http://localhost/technothlon/<API key>/android/?technocoupdoeil=<API key>&lastFetchId=";
private static int download(Context context) {
SharedPreferences sharedPref = context.<API key>(
context.getString(R.string.preference_file_key), Context.MODE_PRIVATE);
long lastFetchID = sharedPref.getLong(context.getString(R.string.tcd_fetch_id), 0);
Log.d("Pref - log", lastFetchID + " from shared pref");
ConnectivityManager connMgr = (ConnectivityManager)
context.getSystemService(Context.<API key>);
NetworkInfo networkInfo = connMgr.<API key>();
if (networkInfo != null && networkInfo.isConnected()) {
try {
JSONObject json = new JSONObject(downloadUrl(url + lastFetchID));
if (json.getString("status").equals("success")) {
TCDDatabase db = new TCDDatabase(context);
JSONArray questions = json.getJSONArray("questions");
lastFetchID = json.getLong("lastFetchId");
int count = json.getInt("questions_count"), lastID;
for (int i = 0; i < count; i++) {
JSONObject q = questions.getJSONObject(i);
JSONObject links = q.getJSONObject("links");
lastID = q.getInt("uniqueId");
db.insert(
lastID,
q.getString("id"),
q.getString("color"),
q.getString("title"),
q.getString("question"),
links.getString("facebook"),
links.getString("google"),
links.getString("tumblr"),
links.getString("answer"),
q.getString("by"),
q.getString("time"),
q.getString("answer")
);
Log.d("Database - log", lastID + " loaded in database");
}
db.close();
SharedPreferences.Editor edit = sharedPref.edit();
edit.putLong(context.getString(R.string.tcd_fetch_id), lastFetchID);
edit.commit();
} else if (json.getString("status").equals("reset")) {
TCDDatabase db = new TCDDatabase(context);
db.reset();
db.close();
SharedPreferences.Editor edit = sharedPref.edit();
edit.putLong(context.getString(R.string.tcd_fetch_id), 0);
edit.commit();
download(context);
}
final Context ct = context;
new Thread() {
@Override
public void run() {
Looper.prepare();
Toast.makeText(ct, "Sync Completed.", Toast.LENGTH_SHORT).show();
Looper.loop();
}
}.start();
return 0;
} catch (JSONException e) {
e.printStackTrace();
final Context ct = context;
new Thread() {
@Override
public void run() {
Looper.prepare();
Toast.makeText(ct, "Sync Failed.", Toast.LENGTH_SHORT).show();
Looper.loop();
}
}.start();
return 3;
} catch (IOException e) {
e.printStackTrace();
final Context ct = context;
new Thread() {
@Override
public void run() {
Looper.prepare();
Toast.makeText(ct, "Sync Failed.", Toast.LENGTH_SHORT).show();
Looper.loop();
}
}.start();
return 2;
}
} else {
final Context ct = context;
new Thread() {
@Override
public void run() {
Looper.prepare();
Toast.makeText(ct, "No network connection available.", Toast.LENGTH_SHORT).show();
Looper.loop();
}
}.start();
return 1;
}
}
private static String downloadUrl(String myurl) throws IOException {
InputStream is = null;
// Only display the first 500 characters of the retrieved
// web page content.
try {
URL url = new URL(myurl);
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setReadTimeout(10000 /* milliseconds */);
conn.setConnectTimeout(15000 /* milliseconds */);
conn.setRequestMethod("GET");
conn.setDoInput(true);
// Starts the query
conn.connect();
int response = conn.getResponseCode();
Log.d("TCD latest downloads", "The response is: " + response);
int size = conn.getContentLength();
Log.d("TCD latest downloads", "The content-length is: " + size);
is = conn.getInputStream();
// Convert the InputStream into a string
return readTextResponse(is);
// Makes sure that the InputStream is closed after the app is
// finished using it.
} finally {
if (is != null) {
is.close();
}
}
}
private static String readTextResponse(InputStream inputStream) throws IOException {
Reader in = new InputStreamReader(inputStream);
BufferedReader bufferedreader = new BufferedReader(in);
StringBuilder stringBuilder = new StringBuilder();
String stringReadLine;
while ((stringReadLine = bufferedreader.readLine()) != null) {
stringBuilder.append(stringReadLine);
}
return stringBuilder.toString();
}
public static void load(Context context) {
boolean update = ITEMS.isEmpty() ? false : true;
TCDDatabase helper = new TCDDatabase(context);
SQLiteDatabase db = helper.getReadableDatabase();
assert db != null;
Cursor c = db.rawQuery("SELECT * FROM " + TCDDatabase.Contracts.NAME + " ORDER BY " + TCDDatabase.Contracts.FIELD_TIME + " DESC, " + TCDDatabase.Contracts.FIELD_ID + " DESC", null);
Log.d("DB", c.getCount() + " object in database");
c.moveToFirst();
while (!c.isAfterLast()) {
addItem(new TCDQuestion(
c.getString(c.getColumnIndex(TCDDatabase.Contracts.FIELD_ID)),
c.getString(c.getColumnIndex(TCDDatabase.Contracts.FIELD_DISPLAY_ID)),
c.getInt(c.getColumnIndex(TCDDatabase.Contracts.FIELD_COLOR)),
c.getString(c.getColumnIndex(TCDDatabase.Contracts.FIELD_TITLE)),
c.getString(c.getColumnIndex(TCDDatabase.Contracts.FIELD_QUESTION)),
c.getString(c.getColumnIndex(TCDDatabase.Contracts.FIELD_FACEBOOK)),
c.getString(c.getColumnIndex(TCDDatabase.Contracts.FIELD_GOOGLE)),
c.getString(c.getColumnIndex(TCDDatabase.Contracts.FIELD_TUMBLR)),
c.getString(c.getColumnIndex(TCDDatabase.Contracts.FIELD_ANSWER_URL)),
c.getString(c.getColumnIndex(TCDDatabase.Contracts.FIELD_BY)),
c.getString(c.getColumnIndex(TCDDatabase.Contracts.FIELD_ANSWER)),
c.getString(c.getColumnIndex(TCDDatabase.Contracts.FIELD_TIME))
), update);
c.moveToNext();
}
c.close();
db.close();
}
private static void addItem(TCDQuestion item, boolean update) {
if (!ITEM_MAP.containsKey(item.uniqueId)) {
if (update) ITEMS.add(0, (new TCDQuestionMini(item.uniqueId)));
else ITEMS.add((new TCDQuestionMini(item.uniqueId)));
ITEM_MAP.put(item.uniqueId, item);
}
}
public abstract static class TCDLoader extends AsyncTask<Object, Integer, Integer> {
@Override
protected Integer doInBackground(Object[] params) {
int d = 4;
try {
d = download((Context) params[0]);
} catch (Exception e) {
e.printStackTrace();
} finally {
load((Context) params[0]);
}
return d;
}
@Override
protected void onPostExecute(Integer o) {
finished(o);
}
public abstract void finished(int result);
}
/**
* A dummy item representing a piece of content.
*/
public static class TCDQuestion {
public String id;
public String question;
public String facebook;
public String google;
public String tumblr;
public String answer_url;
public String by;
public String answer;
public String title;
public java.util.Date date = null;
public String dateString = "";
public int color = R.drawable.tcd_background_1;
public String uniqueId;
private String status;
private boolean ret = false;
public TCDQuestion(String uniqueId, String id, int color, String title, String question, String facebook, String google, String tumblr,
String answer_url, String by, String answer, String status) {
this.uniqueId = uniqueId;
this.id = id;
this.title = title;
this.question = question;
this.facebook = facebook;
this.google = google;
this.tumblr = tumblr;
this.answer_url = answer_url;
this.by = by;
this.color = getBackground(color);
this.answer = answer;
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
try {
this.date = sdf.parse(status);
} catch (ParseException e) {
e.printStackTrace();
}
sdf = new SimpleDateFormat("yyyy-MM-dd");
assert this.date != null;
this.dateString = sdf.format(this.date);
this.status = getStatus();
}
private int getBackground(int color) {
switch (color) {
case 10:
return R.drawable.tcd_background_2;
case 20:
return R.drawable.tcd_background_3;
case 30:
return R.drawable.tcd_background_4;
case 40:
return R.drawable.tcd_background_5;
case 50:
return R.drawable.tcd_background_6;
default:
return R.drawable.tcd_background_1;
}
}
public String getStatus() {
if (ret) return status;
long seconds = Math.abs(((new Date()).getTime() - date.getTime()) / 1000);
if (seconds < 60) status = "about " + seconds + " seconds ago";
else if (seconds < 3600) status = "about " + (seconds / 60) + " minutes ago";
else if (seconds < 86400) status = "about " + (seconds / 3600) + " hours ago";
else if (seconds < 172800) status = "yesterday";
else if (seconds < 345600) status = (seconds / 86400) + " days ago";
else {
ret = true;
status = dateString;
}
return status;
}
}
public static class TCDHolder {
public TextView id, title, question, status;
}
public static class TCDQuestionMini {
public String id;
public TCDQuestionMini(String id) {
this.id = id;
}
}
}
|
import {Component} from '@angular/core';
import {NgbActiveModal} from '@ng-bootstrap/ng-bootstrap';
import {Category} from 'idai-field-core';
import {<API key>} from '../../../core/configuration/<API key>';
@Component({
selector: 'link-modal',
templateUrl: './link-modal.html',
host: {
'(window:keydown)': 'onKeyDown($event)'
}
})
export class LinkModalComponent {
public filterOptions: Array<Category> = [];
constructor(public activeModal: NgbActiveModal,
private <API key>: <API key>) {}
public onKeyDown(event: KeyboardEvent) {
if (event.key === 'Escape') this.activeModal.dismiss('cancel');
}
public <API key>() {
this.filterOptions = this.<API key>.<API key>(
'isDepictedIn', 'Image'
);
}
}
|
Get up to speed on [pandas](http://pandas.pydata.org/) and
[TensorFlow](https:
(click [here](https://github.com/google/eng-edu/blob/master/ml/cc/README.md) for
installation instructions):
* **Hello World:** An introduction to the Datalab notebook environment that
shows how to code ["Hello
World"](https://en.wikipedia.org/wiki/%22Hello,_World!%22_program) in
TensorFlow.
* **TensorFlow Programming Concepts:** A walkthrough of the fundamental
components of a TensorFlow application: tensors, operations, graphs, and
sessions.
* **Creating and Manipulating Tensors:** A quick primer on tensors: the
central abstraction in TensorFlow programming. Also provides a refresher on
matrix addition and multiplication in linear algebra.
* **Quick Introduction to pandas:** A tutorial on basic data manipulation with
pandas.
|
name: (Maintainers Only) Good First Issue
about: For maintainers to create an issue that is good for new contributors
<!-- Issue text below -->
<!-- End issue text, leave the following intact -->
**Good First Issue**: This issue is good for first time contributors. If you've already contributed to Warehouse, work on [another issue without this label](https://github.com/pypa/warehouse/issues?utf8=%E2%9C%93&q=is%3Aissue+is%3Aopen+-label%3A%22good+first+issue%22) instead. If there is not a corresponding pull request for this issue, it is up for grabs. For directions for getting set up, see our [Getting Started Guide](https://warehouse.pypa.io/development/getting-started/). If you are working on this issue and have questions, feel free to ask them here, [`
**Screenshot Required**: *If your pull request makes a visual change*, include a screenshot of your update. This helps our team give you feedback faster.
|
package com.zaaach.citypicker.db;
import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.os.Environment;
import com.zaaach.citypicker.model.City;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
/**
* author Bro0cL on 2016/1/26.
*/
public class DBManager {
private static final String ASSETS_NAME = "china_cities.db";
private static final String DB_NAME = "china_cities.db";
private static final String TABLE_NAME = "city";
private static final String NAME = "name";
private static final String PINYIN = "pinyin";
private static final int BUFFER_SIZE = 1024;
private String DB_PATH;
private Context mContext;
public DBManager(Context context) {
this.mContext = context;
DB_PATH = File.separator + "data"
+ Environment.getDataDirectory().getAbsolutePath() + File.separator
+ context.getPackageName() + File.separator + "databases" + File.separator;
}
@SuppressWarnings("<API key>")
public void copyDBFile(){
File dir = new File(DB_PATH);
if (!dir.exists()){
dir.mkdirs();
}
File dbFile = new File(DB_PATH + DB_NAME);
if (!dbFile.exists()){
InputStream is;
OutputStream os;
try {
is = mContext.getResources().getAssets().open(ASSETS_NAME);
os = new FileOutputStream(dbFile);
byte[] buffer = new byte[BUFFER_SIZE];
int length;
while ((length = is.read(buffer, 0, buffer.length)) > 0){
os.write(buffer, 0, length);
}
os.flush();
os.close();
is.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
public List<City> getAllCities(){
SQLiteDatabase db = SQLiteDatabase.<API key>(DB_PATH + DB_NAME, null);
Cursor cursor = db.rawQuery("select * from " + TABLE_NAME, null);
List<City> result = new ArrayList<>();
City city;
while (cursor.moveToNext()){
String name = cursor.getString(cursor.getColumnIndex(NAME));
String pinyin = cursor.getString(cursor.getColumnIndex(PINYIN));
city = new City(name, pinyin);
result.add(city);
}
cursor.close();
db.close();
Collections.sort(result, new CityComparator());
return result;
}
public List<City> searchCity(final String keyword){
SQLiteDatabase db = SQLiteDatabase.<API key>(DB_PATH + DB_NAME, null);
Cursor cursor = db.rawQuery("select * from " + TABLE_NAME +" where name like \"%" + keyword
+ "%\" or pinyin like \"%" + keyword + "%\"", null);
List<City> result = new ArrayList<>();
City city;
while (cursor.moveToNext()){
String name = cursor.getString(cursor.getColumnIndex(NAME));
String pinyin = cursor.getString(cursor.getColumnIndex(PINYIN));
city = new City(name, pinyin);
result.add(city);
}
cursor.close();
db.close();
Collections.sort(result, new CityComparator());
return result;
}
/**
* sort by a-z
*/
private class CityComparator implements Comparator<City>{
@Override
public int compare(City lhs, City rhs) {
String a = lhs.getPinyin().substring(0, 1);
String b = rhs.getPinyin().substring(0, 1);
return a.compareTo(b);
}
}
}
|
#pragma once
#include "<API key>.h"
namespace autowiring {
<summary>
A single subscription counter entry
</summary>
struct SatCounter:
<API key>
{
SatCounter(void) = default;
SatCounter(const <API key>& source):
<API key>(source),
remaining(m_requiredCount)
{}
SatCounter(const SatCounter& source):
<API key>(static_cast<const <API key>&>(source)),
remaining(source.remaining)
{}
// Forward and backward linked list pointers
SatCounter* flink = nullptr;
SatCounter* blink = nullptr;
// The number of inputs remaining to this counter:
size_t remaining = 0;
<summary>
Conditionally decrements AutoFilter argument satisfaction.
</summary>
<returns>True if this decrement yielded satisfaction of all arguments</returns>
bool Decrement(void) {
return remaining && !--remaining;
}
<summary>
Conditionally increments AutoFilter argument satisfaction.
</summary>
void Increment(void) {
++remaining;
}
};
}
namespace std {
template<>
struct hash<autowiring::SatCounter>
{
size_t operator()(const autowiring::SatCounter& satCounter) const {
return (size_t)satCounter.GetAutoFilter().ptr();
}
};
}
|
using Hyperstore.CodeAnalysis.Syntax;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Hyperstore.CodeAnalysis.Compilation
{
public class HyperstoreCompiler
{
private readonly string _basePath;
private readonly string _outputDirectory;
private <API key> _compilation;
private const string OutputFileName = "Domains.g.cs";
public IEnumerable<Diagnostic> Diagnostics
{
get
{
return _compilation.GetDiagnostics();
}
}
public HyperstoreCompiler(string outputDirectory, string basePath = null)
{
_basePath = basePath;
_outputDirectory = outputDirectory;
}
public bool Run(string[] inputFiles)
{
if (inputFiles == null || inputFiles.Length == 0)
{
ClearOutputFile();
return false;
}
try
{
var trees = new <API key>[inputFiles.Count()];
//if (trees.Length > 1)
// Parallel.For(0, trees.Length, ix =>
// var inputFile = inputFiles[ix];
// string content;
// string normalizedPath;
// if (OpenFile(inputFile, out content, out normalizedPath))
// trees[ix] = <API key>.ParseText(content, normalizedPath);
//else
var i = 0;
foreach (var inputFile in inputFiles)
{
string content;
string normalizedPath;
if (OpenFile(inputFile, out content, out normalizedPath))
{
trees[i++] = <API key>.ParseText(content, normalizedPath);
}
}
_compilation = <API key>.Create("C#", trees.Where(t => t != null));
if (_compilation.HasErrors)
{
ClearOutputFile();
return false;
}
var output = _compilation.Generate();
WriteOutputFile(output);
return true;
}
catch (Exception ex)
{
ClearOutputFile();
throw ex;
}
}
private void ClearOutputFile()
{
var tmp = MakeOutputFilePath();
OutputFilePath = null;
if (File.Exists(tmp))
File.Delete(tmp);
}
private void WriteOutputFile(string output)
{
OutputFilePath = MakeOutputFilePath();
Directory.CreateDirectory(Path.GetDirectoryName(OutputFilePath));
File.WriteAllText(OutputFilePath, output);
OutputFilePath = new FileInfo(OutputFilePath).FullName;
}
private string MakeOutputFilePath()
{
return Path.Combine(_outputDirectory, OutputFileName);
}
public bool OpenFile(string inputFile, out string content, out string normalizedPath)
{
content = null;
normalizedPath = _basePath != null ? Path.Combine(_basePath, inputFile) : inputFile;
if (!File.Exists(normalizedPath))
{
AddDiagnostic("File {0} not found.", normalizedPath);
return false;
}
using (var stream = File.OpenRead(normalizedPath))
{
using (var reader = new StreamReader(stream))
{
content = reader.ReadToEnd();
normalizedPath = stream.Name;
}
}
return true;
}
private void AddDiagnostic(string msg, params string[] args)
{
var diag = Diagnostic.Create(
args.Length == 0 ? msg : String.Format(msg, args),
DiagnosticSeverity.Error);
}
public string OutputFilePath { get; private set; }
}
}
|
// <API key>: Apache-2.0 WITH LLVM-exception
// This file defines an instruction selector for the ARM target.
#include "ARM.h"
#include "ARMBaseInstrInfo.h"
#include "ARMTargetMachine.h"
#include "MCTargetDesc/ARMAddressingModes.h"
#include "Utils/ARMBaseInfo.h"
#include "llvm/ADT/StringSwitch.h"
#include "llvm/CodeGen/MachineFrameInfo.h"
#include "llvm/CodeGen/MachineFunction.h"
#include "llvm/CodeGen/MachineInstrBuilder.h"
#include "llvm/CodeGen/MachineRegisterInfo.h"
#include "llvm/CodeGen/SelectionDAG.h"
#include "llvm/CodeGen/SelectionDAGISel.h"
#include "llvm/CodeGen/TargetLowering.h"
#include "llvm/IR/CallingConv.h"
#include "llvm/IR/Constants.h"
#include "llvm/IR/DerivedTypes.h"
#include "llvm/IR/Function.h"
#include "llvm/IR/Intrinsics.h"
#include "llvm/IR/LLVMContext.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Target/TargetOptions.h"
using namespace llvm;
#define DEBUG_TYPE "arm-isel"
static cl::opt<bool>
DisableShifterOp("disable-shifter-op", cl::Hidden,
cl::desc("Disable isel of shifter-op"),
cl::init(false));
ARMDAGToDAGISel - ARM specific code to select ARM machine
instructions for SelectionDAG operations.
namespace {
class ARMDAGToDAGISel : public SelectionDAGISel {
Subtarget - Keep a pointer to the ARMSubtarget around so that we can
make the right decision when generating code for different targets.
const ARMSubtarget *Subtarget;
public:
explicit ARMDAGToDAGISel(<API key> &tm, CodeGenOpt::Level OptLevel)
: SelectionDAGISel(tm, OptLevel) {}
bool <API key>(MachineFunction &MF) override {
// Reset the subtarget each time through.
Subtarget = &MF.getSubtarget<ARMSubtarget>();
SelectionDAGISel::<API key>(MF);
return true;
}
StringRef getPassName() const override { return "ARM Instruction Selection"; }
void PreprocessISelDAG() override;
getI32Imm - Return a target constant of type i32 with the specified
value.
inline SDValue getI32Imm(unsigned Imm, const SDLoc &dl) {
return CurDAG->getTargetConstant(Imm, dl, MVT::i32);
}
void Select(SDNode *N) override;
bool hasNoVMLxHazardUse(SDNode *N) const;
bool <API key>(const SDValue &Shift,
ARM_AM::ShiftOpc ShOpcVal, unsigned ShAmt);
bool <API key>(SDValue N, SDValue &A,
SDValue &B, SDValue &C,
bool CheckProfitability = true);
bool <API key>(SDValue N, SDValue &A,
SDValue &B, bool CheckProfitability = true);
bool <API key>(SDValue N, SDValue &A,
SDValue &B, SDValue &C) {
// Don't apply the profitability check
return <API key>(N, A, B, C, false);
}
bool <API key>(SDValue N, SDValue &A,
SDValue &B) {
// Don't apply the profitability check
return <API key>(N, A, B, false);
}
bool SelectAddLikeOr(SDNode *Parent, SDValue N, SDValue &Out);
bool SelectAddrModeImm12(SDValue N, SDValue &Base, SDValue &OffImm);
bool SelectLdStSOReg(SDValue N, SDValue &Base, SDValue &Offset, SDValue &Opc);
bool SelectCMOVPred(SDValue N, SDValue &Pred, SDValue &Reg) {
const ConstantSDNode *CN = cast<ConstantSDNode>(N);
Pred = CurDAG->getTargetConstant(CN->getZExtValue(), SDLoc(N), MVT::i32);
Reg = CurDAG->getRegister(ARM::CPSR, MVT::i32);
return true;
}
bool <API key>(SDNode *Op, SDValue N,
SDValue &Offset, SDValue &Opc);
bool <API key>(SDNode *Op, SDValue N,
SDValue &Offset, SDValue &Opc);
bool <API key>(SDNode *Op, SDValue N,
SDValue &Offset, SDValue &Opc);
bool <API key>(SDValue N, SDValue &Base);
bool SelectAddrMode3(SDValue N, SDValue &Base,
SDValue &Offset, SDValue &Opc);
bool <API key>(SDNode *Op, SDValue N,
SDValue &Offset, SDValue &Opc);
bool IsAddressingMode5(SDValue N, SDValue &Base, SDValue &Offset, bool FP16);
bool SelectAddrMode5(SDValue N, SDValue &Base, SDValue &Offset);
bool SelectAddrMode5FP16(SDValue N, SDValue &Base, SDValue &Offset);
bool SelectAddrMode6(SDNode *Parent, SDValue N, SDValue &Addr,SDValue &Align);
bool <API key>(SDNode *Op, SDValue N, SDValue &Offset);
bool SelectAddrModePC(SDValue N, SDValue &Offset, SDValue &Label);
// Thumb Addressing Modes:
bool <API key>(SDValue N, SDValue &Base, SDValue &Offset);
bool <API key>(SDValue N, SDValue &Base, SDValue &Offset);
bool <API key>(SDValue N, unsigned Scale, SDValue &Base,
SDValue &OffImm);
bool <API key>(SDValue N, SDValue &Base,
SDValue &OffImm);
bool <API key>(SDValue N, SDValue &Base,
SDValue &OffImm);
bool <API key>(SDValue N, SDValue &Base,
SDValue &OffImm);
bool <API key>(SDValue N, SDValue &Base, SDValue &OffImm);
// Thumb 2 Addressing Modes:
bool <API key>(SDValue N, SDValue &Base, SDValue &OffImm);
bool <API key>(SDValue N, SDValue &Base,
SDValue &OffImm);
bool <API key>(SDNode *Op, SDValue N,
SDValue &OffImm);
bool <API key>(SDValue N, SDValue &Base,
SDValue &OffReg, SDValue &ShImm);
bool <API key>(SDValue N, SDValue &Base, SDValue &OffImm);
inline bool is_so_imm(unsigned Imm) const {
return ARM_AM::getSOImmVal(Imm) != -1;
}
inline bool is_so_imm_not(unsigned Imm) const {
return ARM_AM::getSOImmVal(~Imm) != -1;
}
inline bool is_t2_so_imm(unsigned Imm) const {
return ARM_AM::getT2SOImmVal(Imm) != -1;
}
inline bool is_t2_so_imm_not(unsigned Imm) const {
return ARM_AM::getT2SOImmVal(~Imm) != -1;
}
// Include the pieces autogenerated from the target description.
#include "ARMGenDAGISel.inc"
private:
void transferMemOperands(SDNode *Src, SDNode *Dst);
Indexed (pre/post inc/dec) load matching code for ARM.
bool tryARMIndexedLoad(SDNode *N);
bool tryT1IndexedLoad(SDNode *N);
bool tryT2IndexedLoad(SDNode *N);
SelectVLD - Select NEON load intrinsics. NumVecs should be
1, 2, 3 or 4. The opcode arrays specify the instructions used for
loads of D registers and even subregs and odd subregs of Q registers.
For NumVecs <= 2, QOpcodes1 is not used.
void SelectVLD(SDNode *N, bool isUpdating, unsigned NumVecs,
const uint16_t *DOpcodes, const uint16_t *QOpcodes0,
const uint16_t *QOpcodes1);
SelectVST - Select NEON store intrinsics. NumVecs should
be 1, 2, 3 or 4. The opcode arrays specify the instructions used for
stores of D registers and even subregs and odd subregs of Q registers.
For NumVecs <= 2, QOpcodes1 is not used.
void SelectVST(SDNode *N, bool isUpdating, unsigned NumVecs,
const uint16_t *DOpcodes, const uint16_t *QOpcodes0,
const uint16_t *QOpcodes1);
SelectVLDSTLane - Select NEON load/store lane intrinsics. NumVecs should
be 2, 3 or 4. The opcode arrays specify the instructions used for
load/store of D registers and Q registers.
void SelectVLDSTLane(SDNode *N, bool IsLoad, bool isUpdating,
unsigned NumVecs, const uint16_t *DOpcodes,
const uint16_t *QOpcodes);
SelectVLDDup - Select NEON load-duplicate intrinsics. NumVecs
should be 1, 2, 3 or 4. The opcode array specifies the instructions used
for loading D registers.
void SelectVLDDup(SDNode *N, bool IsIntrinsic, bool isUpdating,
unsigned NumVecs, const uint16_t *DOpcodes,
const uint16_t *QOpcodes0 = nullptr,
const uint16_t *QOpcodes1 = nullptr);
Try to select SBFX/UBFX instructions for ARM.
bool <API key>(SDNode *N, bool isSigned);
// Select special operations if node forms integer ABS pattern
bool tryABSOp(SDNode *N);
bool tryReadRegister(SDNode *N);
bool tryWriteRegister(SDNode *N);
bool tryInlineAsm(SDNode *N);
void SelectCMPZ(SDNode *N, bool &SwitchEQNEToPLMI);
void SelectCMP_SWAP(SDNode *N);
<API key> - Implement addressing mode selection for
inline asm expressions.
bool <API key>(const SDValue &Op, unsigned ConstraintID,
std::vector<SDValue> &OutOps) override;
// Form pairs of consecutive R, S, D, or Q registers.
SDNode *createGPRPairNode(EVT VT, SDValue V0, SDValue V1);
SDNode *createSRegPairNode(EVT VT, SDValue V0, SDValue V1);
SDNode *createDRegPairNode(EVT VT, SDValue V0, SDValue V1);
SDNode *createQRegPairNode(EVT VT, SDValue V0, SDValue V1);
// Form sequences of 4 consecutive S, D, or Q registers.
SDNode *createQuadSRegsNode(EVT VT, SDValue V0, SDValue V1, SDValue V2, SDValue V3);
SDNode *createQuadDRegsNode(EVT VT, SDValue V0, SDValue V1, SDValue V2, SDValue V3);
SDNode *createQuadQRegsNode(EVT VT, SDValue V0, SDValue V1, SDValue V2, SDValue V3);
// Get the alignment operand for a NEON VLD or VST instruction.
SDValue GetVLDSTAlign(SDValue Align, const SDLoc &dl, unsigned NumVecs,
bool is64BitVector);
Returns the number of instructions required to materialize the given
constant in a register, or 3 if a literal pool load is needed.
unsigned <API key>(unsigned Val) const;
Checks if N is a multiplication by a constant where we can extract out a
power of two from the constant so that it can be used in a shift, but only
if it simplifies the materialization of the constant. Returns true if it
is, and assigns to PowerOfTwo the power of two that should be extracted
out and to NewMulConst the new constant to be multiplied by.
bool <API key>(const SDValue &N, unsigned MaxShift,
unsigned &PowerOfTwo, SDValue &NewMulConst) const;
Replace N with M in CurDAG, in a way that also ensures that M gets
selected when N would have been selected.
void replaceDAGValue(const SDValue &N, SDValue M);
};
}
isInt32Immediate - This method tests to see if the node is a 32-bit constant
operand. If so Imm will receive the 32-bit value.
static bool isInt32Immediate(SDNode *N, unsigned &Imm) {
if (N->getOpcode() == ISD::Constant && N->getValueType(0) == MVT::i32) {
Imm = cast<ConstantSDNode>(N)->getZExtValue();
return true;
}
return false;
}
// isInt32Immediate - This method tests to see if a constant operand.
// If so Imm will receive the 32 bit value.
static bool isInt32Immediate(SDValue N, unsigned &Imm) {
return isInt32Immediate(N.getNode(), Imm);
}
// <API key> - This method tests to see if the node is a specific
// opcode and that it has a immediate integer right operand.
// If so Imm will receive the 32 bit value.
static bool <API key>(SDNode *N, unsigned Opc, unsigned& Imm) {
return N->getOpcode() == Opc &&
isInt32Immediate(N->getOperand(1).getNode(), Imm);
}
Check whether a particular node is a constant value representable as
(N * Scale) where (N in [\p RangeMin, \p RangeMax).
\param ScaledConstant [out] - On success, the pre-scaled constant value.
static bool <API key>(SDValue Node, int Scale,
int RangeMin, int RangeMax,
int &ScaledConstant) {
assert(Scale > 0 && "Invalid scale!");
// Check that this is a constant.
const ConstantSDNode *C = dyn_cast<ConstantSDNode>(Node);
if (!C)
return false;
ScaledConstant = (int) C->getZExtValue();
if ((ScaledConstant % Scale) != 0)
return false;
ScaledConstant /= Scale;
return ScaledConstant >= RangeMin && ScaledConstant < RangeMax;
}
void ARMDAGToDAGISel::PreprocessISelDAG() {
if (!Subtarget->hasV6T2Ops())
return;
bool isThumb2 = Subtarget->isThumb();
for (SelectionDAG::allnodes_iterator I = CurDAG->allnodes_begin(),
E = CurDAG->allnodes_end(); I != E; ) {
SDNode *N = &*I++; // Preincrement iterator to avoid invalidation issues.
if (N->getOpcode() != ISD::ADD)
continue;
// Look for (add X1, (and (srl X2, c1), c2)) where c2 is constant with
// leading zeros, followed by consecutive set bits, followed by 1 or 2
// trailing zeros, e.g. 1020.
// Transform the expression to
// (add X1, (shl (and (srl X2, c1), (c2>>tz)), tz)) where tz is the number
// of trailing zeros of c2. The left shift would be folded as an shifter
// operand of 'add' and the 'and' and 'srl' would become a bits extraction
// node (UBFX).
SDValue N0 = N->getOperand(0);
SDValue N1 = N->getOperand(1);
unsigned And_imm = 0;
if (!<API key>(N1.getNode(), ISD::AND, And_imm)) {
if (<API key>(N0.getNode(), ISD::AND, And_imm))
std::swap(N0, N1);
}
if (!And_imm)
continue;
// Check if the AND mask is an immediate of the form: 000.....1111111100
unsigned TZ = countTrailingZeros(And_imm);
if (TZ != 1 && TZ != 2)
// Be conservative here. Shifter operands aren't always free. e.g. On
// Swift, left shifter operand of 1 / 2 for free but others are not.
// ubfx r3, r1, #16, #8
// ldr.w r3, [r0, r3, lsl
// mov.w r9, #1020
// and.w r2, r9, r1, lsr
// ldr r2, [r0, r2]
continue;
And_imm >>= TZ;
if (And_imm & (And_imm + 1))
continue;
// Look for (and (srl X, c1), c2).
SDValue Srl = N1.getOperand(0);
unsigned Srl_imm = 0;
if (!<API key>(Srl.getNode(), ISD::SRL, Srl_imm) ||
(Srl_imm <= 2))
continue;
// Make sure first operand is not a shifter operand which would prevent
// folding of the left shift.
SDValue CPTmp0;
SDValue CPTmp1;
SDValue CPTmp2;
if (isThumb2) {
if (<API key>(N0, CPTmp0, CPTmp1))
continue;
} else {
if (<API key>(N0, CPTmp0, CPTmp1) ||
<API key>(N0, CPTmp0, CPTmp1, CPTmp2))
continue;
}
// Now make the transformation.
Srl = CurDAG->getNode(ISD::SRL, SDLoc(Srl), MVT::i32,
Srl.getOperand(0),
CurDAG->getConstant(Srl_imm + TZ, SDLoc(Srl),
MVT::i32));
N1 = CurDAG->getNode(ISD::AND, SDLoc(N1), MVT::i32,
Srl,
CurDAG->getConstant(And_imm, SDLoc(Srl), MVT::i32));
N1 = CurDAG->getNode(ISD::SHL, SDLoc(N1), MVT::i32,
N1, CurDAG->getConstant(TZ, SDLoc(Srl), MVT::i32));
CurDAG->UpdateNodeOperands(N, N0, N1);
}
}
hasNoVMLxHazardUse - Return true if it's desirable to select a FP MLA / MLS
node. VFP / NEON fp VMLA / VMLS instructions have special RAW hazards (at
least on current ARM implementations) which should be avoidded.
bool ARMDAGToDAGISel::hasNoVMLxHazardUse(SDNode *N) const {
if (OptLevel == CodeGenOpt::None)
return true;
if (!Subtarget->hasVMLxHazards())
return true;
if (!N->hasOneUse())
return false;
SDNode *Use = *N->use_begin();
if (Use->getOpcode() == ISD::CopyToReg)
return true;
if (Use->isMachineOpcode()) {
const ARMBaseInstrInfo *TII = static_cast<const ARMBaseInstrInfo *>(
CurDAG->getSubtarget().getInstrInfo());
const MCInstrDesc &MCID = TII->get(Use->getMachineOpcode());
if (MCID.mayStore())
return true;
unsigned Opcode = MCID.getOpcode();
if (Opcode == ARM::VMOVRS || Opcode == ARM::VMOVRRD)
return true;
// vmlx feeding into another vmlx. We actually want to unfold
// the use later in the MLxExpansion pass. e.g.
// vmla
// vmla (stall 8 cycles)
// vmul (5 cycles)
// vadd (5 cycles)
// vmla
// This adds up to about 18 - 19 cycles.
// vmla
// vmul (stall 4 cycles)
// vadd adds up to about 14 cycles.
return TII->isFpMLxInstruction(Opcode);
}
return false;
}
bool ARMDAGToDAGISel::<API key>(const SDValue &Shift,
ARM_AM::ShiftOpc ShOpcVal,
unsigned ShAmt) {
if (!Subtarget->isLikeA9() && !Subtarget->isSwift())
return true;
if (Shift.hasOneUse())
return true;
// R << 2 is free.
return ShOpcVal == ARM_AM::lsl &&
(ShAmt == 2 || (Subtarget->isSwift() && ShAmt == 1));
}
unsigned ARMDAGToDAGISel::<API key>(unsigned Val) const {
if (Subtarget->isThumb()) {
if (Val <= 255) return 1; // MOV
if (Subtarget->hasV6T2Ops() &&
(Val <= 0xffff || // MOV
ARM_AM::getT2SOImmVal(Val) != -1 || // MOVW
ARM_AM::getT2SOImmVal(~Val) != -1)) // MVN
return 1;
if (Val <= 510) return 2; // MOV + ADDi8
if (~Val <= 255) return 2; // MOV + MVN
if (ARM_AM::<API key>(Val)) return 2; // MOV + LSL
} else {
if (ARM_AM::getSOImmVal(Val) != -1) return 1; // MOV
if (ARM_AM::getSOImmVal(~Val) != -1) return 1; // MVN
if (Subtarget->hasV6T2Ops() && Val <= 0xffff) return 1; // MOVW
if (ARM_AM::isSOImmTwoPartVal(Val)) return 2; // two instrs
}
if (Subtarget->useMovt()) return 2; // MOVW + MOVT
return 3; // Literal pool load
}
bool ARMDAGToDAGISel::<API key>(const SDValue &N,
unsigned MaxShift,
unsigned &PowerOfTwo,
SDValue &NewMulConst) const {
assert(N.getOpcode() == ISD::MUL);
assert(MaxShift > 0);
// If the multiply is used in more than one place then changing the constant
// will make other uses incorrect, so don't.
if (!N.hasOneUse()) return false;
// Check if the multiply is by a constant
ConstantSDNode *MulConst = dyn_cast<ConstantSDNode>(N.getOperand(1));
if (!MulConst) return false;
// If the constant is used in more than one place then modifying it will mean
// we need to materialize two constants instead of one, which is a bad idea.
if (!MulConst->hasOneUse()) return false;
unsigned MulConstVal = MulConst->getZExtValue();
if (MulConstVal == 0) return false;
// Find the largest power of 2 that MulConstVal is a multiple of
PowerOfTwo = MaxShift;
while ((MulConstVal % (1 << PowerOfTwo)) != 0) {
--PowerOfTwo;
if (PowerOfTwo == 0) return false;
}
// Only optimise if the new cost is better
unsigned NewMulConstVal = MulConstVal / (1 << PowerOfTwo);
NewMulConst = CurDAG->getConstant(NewMulConstVal, SDLoc(N), MVT::i32);
unsigned OldCost = <API key>(MulConstVal);
unsigned NewCost = <API key>(NewMulConstVal);
return NewCost < OldCost;
}
void ARMDAGToDAGISel::replaceDAGValue(const SDValue &N, SDValue M) {
CurDAG->RepositionNode(N.getNode()->getIterator(), M.getNode());
ReplaceUses(N, M);
}
bool ARMDAGToDAGISel::<API key>(SDValue N,
SDValue &BaseReg,
SDValue &Opc,
bool CheckProfitability) {
if (DisableShifterOp)
return false;
// If N is a <API key> and it's profitable to extract a shift and
// use it in a shifted operand do so.
if (N.getOpcode() == ISD::MUL) {
unsigned PowerOfTwo = 0;
SDValue NewMulConst;
if (<API key>(N, 31, PowerOfTwo, NewMulConst)) {
HandleSDNode Handle(N);
SDLoc Loc(N);
replaceDAGValue(N.getOperand(1), NewMulConst);
BaseReg = Handle.getValue();
Opc = CurDAG->getTargetConstant(
ARM_AM::getSORegOpc(ARM_AM::lsl, PowerOfTwo), Loc, MVT::i32);
return true;
}
}
ARM_AM::ShiftOpc ShOpcVal = ARM_AM::getShiftOpcForNode(N.getOpcode());
// Don't match base register only case. That is matched to a separate
// lower complexity pattern with explicit register operand.
if (ShOpcVal == ARM_AM::no_shift) return false;
BaseReg = N.getOperand(0);
unsigned ShImmVal = 0;
ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1));
if (!RHS) return false;
ShImmVal = RHS->getZExtValue() & 31;
Opc = CurDAG->getTargetConstant(ARM_AM::getSORegOpc(ShOpcVal, ShImmVal),
SDLoc(N), MVT::i32);
return true;
}
bool ARMDAGToDAGISel::<API key>(SDValue N,
SDValue &BaseReg,
SDValue &ShReg,
SDValue &Opc,
bool CheckProfitability) {
if (DisableShifterOp)
return false;
ARM_AM::ShiftOpc ShOpcVal = ARM_AM::getShiftOpcForNode(N.getOpcode());
// Don't match base register only case. That is matched to a separate
// lower complexity pattern with explicit register operand.
if (ShOpcVal == ARM_AM::no_shift) return false;
BaseReg = N.getOperand(0);
unsigned ShImmVal = 0;
ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1));
if (RHS) return false;
ShReg = N.getOperand(1);
if (CheckProfitability && !<API key>(N, ShOpcVal, ShImmVal))
return false;
Opc = CurDAG->getTargetConstant(ARM_AM::getSORegOpc(ShOpcVal, ShImmVal),
SDLoc(N), MVT::i32);
return true;
}
// Determine whether an ISD::OR's operands are suitable to turn the operation
// into an addition, which often has more compact encodings.
bool ARMDAGToDAGISel::SelectAddLikeOr(SDNode *Parent, SDValue N, SDValue &Out) {
assert(Parent->getOpcode() == ISD::OR && "unexpected parent");
Out = N;
return CurDAG->haveNoCommonBitsSet(N, Parent->getOperand(1));
}
bool ARMDAGToDAGISel::SelectAddrModeImm12(SDValue N,
SDValue &Base,
SDValue &OffImm) {
// Match simple R + imm12 operands.
// Base only.
if (N.getOpcode() != ISD::ADD && N.getOpcode() != ISD::SUB &&
!CurDAG-><API key>(N)) {
if (N.getOpcode() == ISD::FrameIndex) {
// Match frame index.
int FI = cast<FrameIndexSDNode>(N)->getIndex();
Base = CurDAG->getTargetFrameIndex(
FI, TLI->getPointerTy(CurDAG->getDataLayout()));
OffImm = CurDAG->getTargetConstant(0, SDLoc(N), MVT::i32);
return true;
}
if (N.getOpcode() == ARMISD::Wrapper &&
N.getOperand(0).getOpcode() != ISD::TargetGlobalAddress &&
N.getOperand(0).getOpcode() != ISD::<API key> &&
N.getOperand(0).getOpcode() != ISD::<API key>) {
Base = N.getOperand(0);
} else
Base = N;
OffImm = CurDAG->getTargetConstant(0, SDLoc(N), MVT::i32);
return true;
}
if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1))) {
int RHSC = (int)RHS->getSExtValue();
if (N.getOpcode() == ISD::SUB)
RHSC = -RHSC;
if (RHSC > -0x1000 && RHSC < 0x1000) { // 12 bits
Base = N.getOperand(0);
if (Base.getOpcode() == ISD::FrameIndex) {
int FI = cast<FrameIndexSDNode>(Base)->getIndex();
Base = CurDAG->getTargetFrameIndex(
FI, TLI->getPointerTy(CurDAG->getDataLayout()));
}
OffImm = CurDAG->getTargetConstant(RHSC, SDLoc(N), MVT::i32);
return true;
}
}
// Base only.
Base = N;
OffImm = CurDAG->getTargetConstant(0, SDLoc(N), MVT::i32);
return true;
}
bool ARMDAGToDAGISel::SelectLdStSOReg(SDValue N, SDValue &Base, SDValue &Offset,
SDValue &Opc) {
if (N.getOpcode() == ISD::MUL &&
((!Subtarget->isLikeA9() && !Subtarget->isSwift()) || N.hasOneUse())) {
if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1))) {
// X * [3,5,9] -> X + X * [2,4,8] etc.
int RHSC = (int)RHS->getZExtValue();
if (RHSC & 1) {
RHSC = RHSC & ~1;
ARM_AM::AddrOpc AddSub = ARM_AM::add;
if (RHSC < 0) {
AddSub = ARM_AM::sub;
RHSC = - RHSC;
}
if (isPowerOf2_32(RHSC)) {
unsigned ShAmt = Log2_32(RHSC);
Base = Offset = N.getOperand(0);
Opc = CurDAG->getTargetConstant(ARM_AM::getAM2Opc(AddSub, ShAmt,
ARM_AM::lsl),
SDLoc(N), MVT::i32);
return true;
}
}
}
}
if (N.getOpcode() != ISD::ADD && N.getOpcode() != ISD::SUB &&
// ISD::OR that is equivalent to an ISD::ADD.
!CurDAG-><API key>(N))
return false;
// Leave simple R +/- imm12 operands for LDRi12
if (N.getOpcode() == ISD::ADD || N.getOpcode() == ISD::OR) {
int RHSC;
if (<API key>(N.getOperand(1), /*Scale=*/1,
-0x1000+1, 0x1000, RHSC)) // 12 bits.
return false;
}
// Otherwise this is R +/- [possibly shifted] R.
ARM_AM::AddrOpc AddSub = N.getOpcode() == ISD::SUB ? ARM_AM::sub:ARM_AM::add;
ARM_AM::ShiftOpc ShOpcVal =
ARM_AM::getShiftOpcForNode(N.getOperand(1).getOpcode());
unsigned ShAmt = 0;
Base = N.getOperand(0);
Offset = N.getOperand(1);
if (ShOpcVal != ARM_AM::no_shift) {
// Check to see if the RHS of the shift is a constant, if not, we can't fold
if (ConstantSDNode *Sh =
dyn_cast<ConstantSDNode>(N.getOperand(1).getOperand(1))) {
ShAmt = Sh->getZExtValue();
if (<API key>(Offset, ShOpcVal, ShAmt))
Offset = N.getOperand(1).getOperand(0);
else {
ShAmt = 0;
ShOpcVal = ARM_AM::no_shift;
}
} else {
ShOpcVal = ARM_AM::no_shift;
}
}
// Try matching (R shl C) + (R).
if (N.getOpcode() != ISD::SUB && ShOpcVal == ARM_AM::no_shift &&
!(Subtarget->isLikeA9() || Subtarget->isSwift() ||
N.getOperand(0).hasOneUse())) {
ShOpcVal = ARM_AM::getShiftOpcForNode(N.getOperand(0).getOpcode());
if (ShOpcVal != ARM_AM::no_shift) {
// Check to see if the RHS of the shift is a constant, if not, we can't
// fold it.
if (ConstantSDNode *Sh =
dyn_cast<ConstantSDNode>(N.getOperand(0).getOperand(1))) {
ShAmt = Sh->getZExtValue();
if (<API key>(N.getOperand(0), ShOpcVal, ShAmt)) {
Offset = N.getOperand(0).getOperand(0);
Base = N.getOperand(1);
} else {
ShAmt = 0;
ShOpcVal = ARM_AM::no_shift;
}
} else {
ShOpcVal = ARM_AM::no_shift;
}
}
}
// If Offset is a <API key> and it's profitable to extract a shift
// and use it in a shifted operand do so.
if (Offset.getOpcode() == ISD::MUL && N.hasOneUse()) {
unsigned PowerOfTwo = 0;
SDValue NewMulConst;
if (<API key>(Offset, 31, PowerOfTwo, NewMulConst)) {
HandleSDNode Handle(Offset);
replaceDAGValue(Offset.getOperand(1), NewMulConst);
Offset = Handle.getValue();
ShAmt = PowerOfTwo;
ShOpcVal = ARM_AM::lsl;
}
}
Opc = CurDAG->getTargetConstant(ARM_AM::getAM2Opc(AddSub, ShAmt, ShOpcVal),
SDLoc(N), MVT::i32);
return true;
}
bool ARMDAGToDAGISel::<API key>(SDNode *Op, SDValue N,
SDValue &Offset, SDValue &Opc) {
unsigned Opcode = Op->getOpcode();
ISD::MemIndexedMode AM = (Opcode == ISD::LOAD)
? cast<LoadSDNode>(Op)->getAddressingMode()
: cast<StoreSDNode>(Op)->getAddressingMode();
ARM_AM::AddrOpc AddSub = (AM == ISD::PRE_INC || AM == ISD::POST_INC)
? ARM_AM::add : ARM_AM::sub;
int Val;
if (<API key>(N, /*Scale=*/1, 0, 0x1000, Val))
return false;
Offset = N;
ARM_AM::ShiftOpc ShOpcVal = ARM_AM::getShiftOpcForNode(N.getOpcode());
unsigned ShAmt = 0;
if (ShOpcVal != ARM_AM::no_shift) {
// Check to see if the RHS of the shift is a constant, if not, we can't fold
if (ConstantSDNode *Sh = dyn_cast<ConstantSDNode>(N.getOperand(1))) {
ShAmt = Sh->getZExtValue();
if (<API key>(N, ShOpcVal, ShAmt))
Offset = N.getOperand(0);
else {
ShAmt = 0;
ShOpcVal = ARM_AM::no_shift;
}
} else {
ShOpcVal = ARM_AM::no_shift;
}
}
Opc = CurDAG->getTargetConstant(ARM_AM::getAM2Opc(AddSub, ShAmt, ShOpcVal),
SDLoc(N), MVT::i32);
return true;
}
bool ARMDAGToDAGISel::<API key>(SDNode *Op, SDValue N,
SDValue &Offset, SDValue &Opc) {
unsigned Opcode = Op->getOpcode();
ISD::MemIndexedMode AM = (Opcode == ISD::LOAD)
? cast<LoadSDNode>(Op)->getAddressingMode()
: cast<StoreSDNode>(Op)->getAddressingMode();
ARM_AM::AddrOpc AddSub = (AM == ISD::PRE_INC || AM == ISD::POST_INC)
? ARM_AM::add : ARM_AM::sub;
int Val;
if (<API key>(N, /*Scale=*/1, 0, 0x1000, Val)) { // 12 bits.
if (AddSub == ARM_AM::sub) Val *= -1;
Offset = CurDAG->getRegister(0, MVT::i32);
Opc = CurDAG->getTargetConstant(Val, SDLoc(Op), MVT::i32);
return true;
}
return false;
}
bool ARMDAGToDAGISel::<API key>(SDNode *Op, SDValue N,
SDValue &Offset, SDValue &Opc) {
unsigned Opcode = Op->getOpcode();
ISD::MemIndexedMode AM = (Opcode == ISD::LOAD)
? cast<LoadSDNode>(Op)->getAddressingMode()
: cast<StoreSDNode>(Op)->getAddressingMode();
ARM_AM::AddrOpc AddSub = (AM == ISD::PRE_INC || AM == ISD::POST_INC)
? ARM_AM::add : ARM_AM::sub;
int Val;
if (<API key>(N, /*Scale=*/1, 0, 0x1000, Val)) { // 12 bits.
Offset = CurDAG->getRegister(0, MVT::i32);
Opc = CurDAG->getTargetConstant(ARM_AM::getAM2Opc(AddSub, Val,
ARM_AM::no_shift),
SDLoc(Op), MVT::i32);
return true;
}
return false;
}
bool ARMDAGToDAGISel::<API key>(SDValue N, SDValue &Base) {
Base = N;
return true;
}
bool ARMDAGToDAGISel::SelectAddrMode3(SDValue N,
SDValue &Base, SDValue &Offset,
SDValue &Opc) {
if (N.getOpcode() == ISD::SUB) {
// X - C is canonicalize to X + -C, no need to handle it here.
Base = N.getOperand(0);
Offset = N.getOperand(1);
Opc = CurDAG->getTargetConstant(ARM_AM::getAM3Opc(ARM_AM::sub, 0), SDLoc(N),
MVT::i32);
return true;
}
if (!CurDAG-><API key>(N)) {
Base = N;
if (N.getOpcode() == ISD::FrameIndex) {
int FI = cast<FrameIndexSDNode>(N)->getIndex();
Base = CurDAG->getTargetFrameIndex(
FI, TLI->getPointerTy(CurDAG->getDataLayout()));
}
Offset = CurDAG->getRegister(0, MVT::i32);
Opc = CurDAG->getTargetConstant(ARM_AM::getAM3Opc(ARM_AM::add, 0), SDLoc(N),
MVT::i32);
return true;
}
// If the RHS is +/- imm8, fold into addr mode.
int RHSC;
if (<API key>(N.getOperand(1), /*Scale=*/1,
-256 + 1, 256, RHSC)) { // 8 bits.
Base = N.getOperand(0);
if (Base.getOpcode() == ISD::FrameIndex) {
int FI = cast<FrameIndexSDNode>(Base)->getIndex();
Base = CurDAG->getTargetFrameIndex(
FI, TLI->getPointerTy(CurDAG->getDataLayout()));
}
Offset = CurDAG->getRegister(0, MVT::i32);
ARM_AM::AddrOpc AddSub = ARM_AM::add;
if (RHSC < 0) {
AddSub = ARM_AM::sub;
RHSC = -RHSC;
}
Opc = CurDAG->getTargetConstant(ARM_AM::getAM3Opc(AddSub, RHSC), SDLoc(N),
MVT::i32);
return true;
}
Base = N.getOperand(0);
Offset = N.getOperand(1);
Opc = CurDAG->getTargetConstant(ARM_AM::getAM3Opc(ARM_AM::add, 0), SDLoc(N),
MVT::i32);
return true;
}
bool ARMDAGToDAGISel::<API key>(SDNode *Op, SDValue N,
SDValue &Offset, SDValue &Opc) {
unsigned Opcode = Op->getOpcode();
ISD::MemIndexedMode AM = (Opcode == ISD::LOAD)
? cast<LoadSDNode>(Op)->getAddressingMode()
: cast<StoreSDNode>(Op)->getAddressingMode();
ARM_AM::AddrOpc AddSub = (AM == ISD::PRE_INC || AM == ISD::POST_INC)
? ARM_AM::add : ARM_AM::sub;
int Val;
if (<API key>(N, /*Scale=*/1, 0, 256, Val)) { // 12 bits.
Offset = CurDAG->getRegister(0, MVT::i32);
Opc = CurDAG->getTargetConstant(ARM_AM::getAM3Opc(AddSub, Val), SDLoc(Op),
MVT::i32);
return true;
}
Offset = N;
Opc = CurDAG->getTargetConstant(ARM_AM::getAM3Opc(AddSub, 0), SDLoc(Op),
MVT::i32);
return true;
}
bool ARMDAGToDAGISel::IsAddressingMode5(SDValue N, SDValue &Base, SDValue &Offset,
bool FP16) {
if (!CurDAG-><API key>(N)) {
Base = N;
if (N.getOpcode() == ISD::FrameIndex) {
int FI = cast<FrameIndexSDNode>(N)->getIndex();
Base = CurDAG->getTargetFrameIndex(
FI, TLI->getPointerTy(CurDAG->getDataLayout()));
} else if (N.getOpcode() == ARMISD::Wrapper &&
N.getOperand(0).getOpcode() != ISD::TargetGlobalAddress &&
N.getOperand(0).getOpcode() != ISD::<API key> &&
N.getOperand(0).getOpcode() != ISD::<API key>) {
Base = N.getOperand(0);
}
Offset = CurDAG->getTargetConstant(ARM_AM::getAM5Opc(ARM_AM::add, 0),
SDLoc(N), MVT::i32);
return true;
}
// If the RHS is +/- imm8, fold into addr mode.
int RHSC;
const int Scale = FP16 ? 2 : 4;
if (<API key>(N.getOperand(1), Scale, -255, 256, RHSC)) {
Base = N.getOperand(0);
if (Base.getOpcode() == ISD::FrameIndex) {
int FI = cast<FrameIndexSDNode>(Base)->getIndex();
Base = CurDAG->getTargetFrameIndex(
FI, TLI->getPointerTy(CurDAG->getDataLayout()));
}
ARM_AM::AddrOpc AddSub = ARM_AM::add;
if (RHSC < 0) {
AddSub = ARM_AM::sub;
RHSC = -RHSC;
}
if (FP16)
Offset = CurDAG->getTargetConstant(ARM_AM::getAM5FP16Opc(AddSub, RHSC),
SDLoc(N), MVT::i32);
else
Offset = CurDAG->getTargetConstant(ARM_AM::getAM5Opc(AddSub, RHSC),
SDLoc(N), MVT::i32);
return true;
}
Base = N;
if (FP16)
Offset = CurDAG->getTargetConstant(ARM_AM::getAM5FP16Opc(ARM_AM::add, 0),
SDLoc(N), MVT::i32);
else
Offset = CurDAG->getTargetConstant(ARM_AM::getAM5Opc(ARM_AM::add, 0),
SDLoc(N), MVT::i32);
return true;
}
bool ARMDAGToDAGISel::SelectAddrMode5(SDValue N,
SDValue &Base, SDValue &Offset) {
return IsAddressingMode5(N, Base, Offset, /*FP16=*/ false);
}
bool ARMDAGToDAGISel::SelectAddrMode5FP16(SDValue N,
SDValue &Base, SDValue &Offset) {
return IsAddressingMode5(N, Base, Offset, /*FP16=*/ true);
}
bool ARMDAGToDAGISel::SelectAddrMode6(SDNode *Parent, SDValue N, SDValue &Addr,
SDValue &Align) {
Addr = N;
unsigned Alignment = 0;
MemSDNode *MemN = cast<MemSDNode>(Parent);
if (isa<LSBaseSDNode>(MemN) ||
((MemN->getOpcode() == ARMISD::VST1_UPD ||
MemN->getOpcode() == ARMISD::VLD1_UPD) &&
MemN-><API key>(MemN->getNumOperands() - 1) == 1)) {
// This case occurs only for VLD1-lane/dup and VST1-lane instructions.
// The maximum alignment is equal to the memory size being referenced.
unsigned MMOAlign = MemN->getAlignment();
unsigned MemSize = MemN->getMemoryVT().getSizeInBits() / 8;
if (MMOAlign >= MemSize && MemSize > 1)
Alignment = MemSize;
} else {
// All other uses of addrmode6 are for intrinsics. For now just record
// alignment operands for the intrinsic.
Alignment = MemN->getAlignment();
}
Align = CurDAG->getTargetConstant(Alignment, SDLoc(N), MVT::i32);
return true;
}
bool ARMDAGToDAGISel::<API key>(SDNode *Op, SDValue N,
SDValue &Offset) {
LSBaseSDNode *LdSt = cast<LSBaseSDNode>(Op);
ISD::MemIndexedMode AM = LdSt->getAddressingMode();
if (AM != ISD::POST_INC)
return false;
Offset = N;
if (ConstantSDNode *NC = dyn_cast<ConstantSDNode>(N)) {
if (NC->getZExtValue() * 8 == LdSt->getMemoryVT().getSizeInBits())
Offset = CurDAG->getRegister(0, MVT::i32);
}
return true;
}
bool ARMDAGToDAGISel::SelectAddrModePC(SDValue N,
SDValue &Offset, SDValue &Label) {
if (N.getOpcode() == ARMISD::PIC_ADD && N.hasOneUse()) {
Offset = N.getOperand(0);
SDValue N1 = N.getOperand(1);
Label = CurDAG->getTargetConstant(cast<ConstantSDNode>(N1)->getZExtValue(),
SDLoc(N), MVT::i32);
return true;
}
return false;
}
// Thumb Addressing Modes
static bool <API key>(SDValue N) {
// Negative numbers are difficult to materialise in thumb1. If we are
// selecting the add of a negative, instead try to select ri with a zero
// offset, so create the add node directly which will become a sub.
if (N.getOpcode() != ISD::ADD)
return false;
if (auto C = dyn_cast<ConstantSDNode>(N.getOperand(1)))
return C->getSExtValue() < 0 && C->getSExtValue() >= -255;
return false;
}
bool ARMDAGToDAGISel::<API key>(SDValue N, SDValue &Base,
SDValue &Offset) {
if (N.getOpcode() != ISD::ADD && !CurDAG-><API key>(N)) {
ConstantSDNode *NC = dyn_cast<ConstantSDNode>(N);
if (!NC || !NC->isNullValue())
return false;
Base = Offset = N;
return true;
}
Base = N.getOperand(0);
Offset = N.getOperand(1);
return true;
}
bool ARMDAGToDAGISel::<API key>(SDValue N, SDValue &Base,
SDValue &Offset) {
if (<API key>(N))
return false; // Select ri instead
return <API key>(N, Base, Offset);
}
bool
ARMDAGToDAGISel::<API key>(SDValue N, unsigned Scale,
SDValue &Base, SDValue &OffImm) {
if (<API key>(N)) {
Base = N;
OffImm = CurDAG->getTargetConstant(0, SDLoc(N), MVT::i32);
return true;
}
if (!CurDAG-><API key>(N)) {
if (N.getOpcode() == ISD::ADD) {
return false; // We want to select register offset instead
} else if (N.getOpcode() == ARMISD::Wrapper &&
N.getOperand(0).getOpcode() != ISD::TargetGlobalAddress &&
N.getOperand(0).getOpcode() != ISD::<API key> &&
N.getOperand(0).getOpcode() != ISD::TargetConstantPool &&
N.getOperand(0).getOpcode() != ISD::<API key>) {
Base = N.getOperand(0);
} else {
Base = N;
}
OffImm = CurDAG->getTargetConstant(0, SDLoc(N), MVT::i32);
return true;
}
// If the RHS is + imm5 * scale, fold into addr mode.
int RHSC;
if (<API key>(N.getOperand(1), Scale, 0, 32, RHSC)) {
Base = N.getOperand(0);
OffImm = CurDAG->getTargetConstant(RHSC, SDLoc(N), MVT::i32);
return true;
}
// Offset is too large, so use register offset instead.
return false;
}
bool
ARMDAGToDAGISel::<API key>(SDValue N, SDValue &Base,
SDValue &OffImm) {
return <API key>(N, 4, Base, OffImm);
}
bool
ARMDAGToDAGISel::<API key>(SDValue N, SDValue &Base,
SDValue &OffImm) {
return <API key>(N, 2, Base, OffImm);
}
bool
ARMDAGToDAGISel::<API key>(SDValue N, SDValue &Base,
SDValue &OffImm) {
return <API key>(N, 1, Base, OffImm);
}
bool ARMDAGToDAGISel::<API key>(SDValue N,
SDValue &Base, SDValue &OffImm) {
if (N.getOpcode() == ISD::FrameIndex) {
int FI = cast<FrameIndexSDNode>(N)->getIndex();
// Only multiples of 4 are allowed for the offset, so the frame object
// alignment must be at least 4.
MachineFrameInfo &MFI = MF->getFrameInfo();
if (MFI.getObjectAlignment(FI) < 4)
MFI.setObjectAlignment(FI, 4);
Base = CurDAG->getTargetFrameIndex(
FI, TLI->getPointerTy(CurDAG->getDataLayout()));
OffImm = CurDAG->getTargetConstant(0, SDLoc(N), MVT::i32);
return true;
}
if (!CurDAG-><API key>(N))
return false;
if (N.getOperand(0).getOpcode() == ISD::FrameIndex) {
// If the RHS is + imm8 * scale, fold into addr mode.
int RHSC;
if (<API key>(N.getOperand(1), /*Scale=*/4, 0, 256, RHSC)) {
Base = N.getOperand(0);
int FI = cast<FrameIndexSDNode>(Base)->getIndex();
// For LHS+RHS to result in an offset that's a multiple of 4 the object
// indexed by the LHS must be 4-byte aligned.
MachineFrameInfo &MFI = MF->getFrameInfo();
if (MFI.getObjectAlignment(FI) < 4)
MFI.setObjectAlignment(FI, 4);
Base = CurDAG->getTargetFrameIndex(
FI, TLI->getPointerTy(CurDAG->getDataLayout()));
OffImm = CurDAG->getTargetConstant(RHSC, SDLoc(N), MVT::i32);
return true;
}
}
return false;
}
// Thumb 2 Addressing Modes
bool ARMDAGToDAGISel::<API key>(SDValue N,
SDValue &Base, SDValue &OffImm) {
// Match simple R + imm12 operands.
// Base only.
if (N.getOpcode() != ISD::ADD && N.getOpcode() != ISD::SUB &&
!CurDAG-><API key>(N)) {
if (N.getOpcode() == ISD::FrameIndex) {
// Match frame index.
int FI = cast<FrameIndexSDNode>(N)->getIndex();
Base = CurDAG->getTargetFrameIndex(
FI, TLI->getPointerTy(CurDAG->getDataLayout()));
OffImm = CurDAG->getTargetConstant(0, SDLoc(N), MVT::i32);
return true;
}
if (N.getOpcode() == ARMISD::Wrapper &&
N.getOperand(0).getOpcode() != ISD::TargetGlobalAddress &&
N.getOperand(0).getOpcode() != ISD::<API key> &&
N.getOperand(0).getOpcode() != ISD::<API key>) {
Base = N.getOperand(0);
if (Base.getOpcode() == ISD::TargetConstantPool)
return false; // We want to select t2LDRpci instead.
} else
Base = N;
OffImm = CurDAG->getTargetConstant(0, SDLoc(N), MVT::i32);
return true;
}
if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1))) {
if (<API key>(N, Base, OffImm))
// Let t2LDRi8 handle (R - imm8).
return false;
int RHSC = (int)RHS->getZExtValue();
if (N.getOpcode() == ISD::SUB)
RHSC = -RHSC;
if (RHSC >= 0 && RHSC < 0x1000) { // 12 bits (unsigned)
Base = N.getOperand(0);
if (Base.getOpcode() == ISD::FrameIndex) {
int FI = cast<FrameIndexSDNode>(Base)->getIndex();
Base = CurDAG->getTargetFrameIndex(
FI, TLI->getPointerTy(CurDAG->getDataLayout()));
}
OffImm = CurDAG->getTargetConstant(RHSC, SDLoc(N), MVT::i32);
return true;
}
}
// Base only.
Base = N;
OffImm = CurDAG->getTargetConstant(0, SDLoc(N), MVT::i32);
return true;
}
bool ARMDAGToDAGISel::<API key>(SDValue N,
SDValue &Base, SDValue &OffImm) {
// Match simple R - imm8 operands.
if (N.getOpcode() != ISD::ADD && N.getOpcode() != ISD::SUB &&
!CurDAG-><API key>(N))
return false;
if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1))) {
int RHSC = (int)RHS->getSExtValue();
if (N.getOpcode() == ISD::SUB)
RHSC = -RHSC;
if ((RHSC >= -255) && (RHSC < 0)) { // 8 bits (always negative)
Base = N.getOperand(0);
if (Base.getOpcode() == ISD::FrameIndex) {
int FI = cast<FrameIndexSDNode>(Base)->getIndex();
Base = CurDAG->getTargetFrameIndex(
FI, TLI->getPointerTy(CurDAG->getDataLayout()));
}
OffImm = CurDAG->getTargetConstant(RHSC, SDLoc(N), MVT::i32);
return true;
}
}
return false;
}
bool ARMDAGToDAGISel::<API key>(SDNode *Op, SDValue N,
SDValue &OffImm){
unsigned Opcode = Op->getOpcode();
ISD::MemIndexedMode AM = (Opcode == ISD::LOAD)
? cast<LoadSDNode>(Op)->getAddressingMode()
: cast<StoreSDNode>(Op)->getAddressingMode();
int RHSC;
if (<API key>(N, /*Scale=*/1, 0, 0x100, RHSC)) { // 8 bits.
OffImm = ((AM == ISD::PRE_INC) || (AM == ISD::POST_INC))
? CurDAG->getTargetConstant(RHSC, SDLoc(N), MVT::i32)
: CurDAG->getTargetConstant(-RHSC, SDLoc(N), MVT::i32);
return true;
}
return false;
}
bool ARMDAGToDAGISel::<API key>(SDValue N,
SDValue &Base,
SDValue &OffReg, SDValue &ShImm) {
// (R - imm8) should be handled by t2LDRi8. The rest are handled by t2LDRi12.
if (N.getOpcode() != ISD::ADD && !CurDAG-><API key>(N))
return false;
// Leave (R + imm12) for t2LDRi12, (R - imm8) for t2LDRi8.
if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1))) {
int RHSC = (int)RHS->getZExtValue();
if (RHSC >= 0 && RHSC < 0x1000) // 12 bits (unsigned)
return false;
else if (RHSC < 0 && RHSC >= -255) // 8 bits
return false;
}
// Look for (R + R) or (R + (R << [1,2,3])).
unsigned ShAmt = 0;
Base = N.getOperand(0);
OffReg = N.getOperand(1);
// Swap if it is ((R << c) + R).
ARM_AM::ShiftOpc ShOpcVal = ARM_AM::getShiftOpcForNode(OffReg.getOpcode());
if (ShOpcVal != ARM_AM::lsl) {
ShOpcVal = ARM_AM::getShiftOpcForNode(Base.getOpcode());
if (ShOpcVal == ARM_AM::lsl)
std::swap(Base, OffReg);
}
if (ShOpcVal == ARM_AM::lsl) {
// Check to see if the RHS of the shift is a constant, if not, we can't fold
if (ConstantSDNode *Sh = dyn_cast<ConstantSDNode>(OffReg.getOperand(1))) {
ShAmt = Sh->getZExtValue();
if (ShAmt < 4 && <API key>(OffReg, ShOpcVal, ShAmt))
OffReg = OffReg.getOperand(0);
else {
ShAmt = 0;
}
}
}
// If OffReg is a <API key> and it's profitable to extract a shift
// and use it in a shifted operand do so.
if (OffReg.getOpcode() == ISD::MUL && N.hasOneUse()) {
unsigned PowerOfTwo = 0;
SDValue NewMulConst;
if (<API key>(OffReg, 3, PowerOfTwo, NewMulConst)) {
HandleSDNode Handle(OffReg);
replaceDAGValue(OffReg.getOperand(1), NewMulConst);
OffReg = Handle.getValue();
ShAmt = PowerOfTwo;
}
}
ShImm = CurDAG->getTargetConstant(ShAmt, SDLoc(N), MVT::i32);
return true;
}
bool ARMDAGToDAGISel::<API key>(SDValue N, SDValue &Base,
SDValue &OffImm) {
// This *must* succeed since it's used for the irreplaceable ldrex and strex
// instructions.
Base = N;
OffImm = CurDAG->getTargetConstant(0, SDLoc(N), MVT::i32);
if (N.getOpcode() != ISD::ADD || !CurDAG-><API key>(N))
return true;
ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1));
if (!RHS)
return true;
uint32_t RHSC = (int)RHS->getZExtValue();
if (RHSC > 1020 || RHSC % 4 != 0)
return true;
Base = N.getOperand(0);
if (Base.getOpcode() == ISD::FrameIndex) {
int FI = cast<FrameIndexSDNode>(Base)->getIndex();
Base = CurDAG->getTargetFrameIndex(
FI, TLI->getPointerTy(CurDAG->getDataLayout()));
}
OffImm = CurDAG->getTargetConstant(RHSC/4, SDLoc(N), MVT::i32);
return true;
}
getAL - Returns a ARMCC::AL immediate node.
static inline SDValue getAL(SelectionDAG *CurDAG, const SDLoc &dl) {
return CurDAG->getTargetConstant((uint64_t)ARMCC::AL, dl, MVT::i32);
}
void ARMDAGToDAGISel::transferMemOperands(SDNode *N, SDNode *Result) {
MachineMemOperand *MemOp = cast<MemSDNode>(N)->getMemOperand();
CurDAG->setNodeMemRefs(cast<MachineSDNode>(Result), {MemOp});
}
bool ARMDAGToDAGISel::tryARMIndexedLoad(SDNode *N) {
LoadSDNode *LD = cast<LoadSDNode>(N);
ISD::MemIndexedMode AM = LD->getAddressingMode();
if (AM == ISD::UNINDEXED)
return false;
EVT LoadedVT = LD->getMemoryVT();
SDValue Offset, AMOpc;
bool isPre = (AM == ISD::PRE_INC) || (AM == ISD::PRE_DEC);
unsigned Opcode = 0;
bool Match = false;
if (LoadedVT == MVT::i32 && isPre &&
<API key>(N, LD->getOffset(), Offset, AMOpc)) {
Opcode = ARM::LDR_PRE_IMM;
Match = true;
} else if (LoadedVT == MVT::i32 && !isPre &&
<API key>(N, LD->getOffset(), Offset, AMOpc)) {
Opcode = ARM::LDR_POST_IMM;
Match = true;
} else if (LoadedVT == MVT::i32 &&
<API key>(N, LD->getOffset(), Offset, AMOpc)) {
Opcode = isPre ? ARM::LDR_PRE_REG : ARM::LDR_POST_REG;
Match = true;
} else if (LoadedVT == MVT::i16 &&
<API key>(N, LD->getOffset(), Offset, AMOpc)) {
Match = true;
Opcode = (LD->getExtensionType() == ISD::SEXTLOAD)
? (isPre ? ARM::LDRSH_PRE : ARM::LDRSH_POST)
: (isPre ? ARM::LDRH_PRE : ARM::LDRH_POST);
} else if (LoadedVT == MVT::i8 || LoadedVT == MVT::i1) {
if (LD->getExtensionType() == ISD::SEXTLOAD) {
if (<API key>(N, LD->getOffset(), Offset, AMOpc)) {
Match = true;
Opcode = isPre ? ARM::LDRSB_PRE : ARM::LDRSB_POST;
}
} else {
if (isPre &&
<API key>(N, LD->getOffset(), Offset, AMOpc)) {
Match = true;
Opcode = ARM::LDRB_PRE_IMM;
} else if (!isPre &&
<API key>(N, LD->getOffset(), Offset, AMOpc)) {
Match = true;
Opcode = ARM::LDRB_POST_IMM;
} else if (<API key>(N, LD->getOffset(), Offset, AMOpc)) {
Match = true;
Opcode = isPre ? ARM::LDRB_PRE_REG : ARM::LDRB_POST_REG;
}
}
}
if (Match) {
if (Opcode == ARM::LDR_PRE_IMM || Opcode == ARM::LDRB_PRE_IMM) {
SDValue Chain = LD->getChain();
SDValue Base = LD->getBasePtr();
SDValue Ops[]= { Base, AMOpc, getAL(CurDAG, SDLoc(N)),
CurDAG->getRegister(0, MVT::i32), Chain };
SDNode *New = CurDAG->getMachineNode(Opcode, SDLoc(N), MVT::i32, MVT::i32,
MVT::Other, Ops);
transferMemOperands(N, New);
ReplaceNode(N, New);
return true;
} else {
SDValue Chain = LD->getChain();
SDValue Base = LD->getBasePtr();
SDValue Ops[]= { Base, Offset, AMOpc, getAL(CurDAG, SDLoc(N)),
CurDAG->getRegister(0, MVT::i32), Chain };
SDNode *New = CurDAG->getMachineNode(Opcode, SDLoc(N), MVT::i32, MVT::i32,
MVT::Other, Ops);
transferMemOperands(N, New);
ReplaceNode(N, New);
return true;
}
}
return false;
}
bool ARMDAGToDAGISel::tryT1IndexedLoad(SDNode *N) {
LoadSDNode *LD = cast<LoadSDNode>(N);
EVT LoadedVT = LD->getMemoryVT();
ISD::MemIndexedMode AM = LD->getAddressingMode();
if (AM != ISD::POST_INC || LD->getExtensionType() != ISD::NON_EXTLOAD ||
LoadedVT.getSimpleVT().SimpleTy != MVT::i32)
return false;
auto *COffs = dyn_cast<ConstantSDNode>(LD->getOffset());
if (!COffs || COffs->getZExtValue() != 4)
return false;
// A T1 post-indexed load is just a single register LDM: LDM r0!, {r1}.
// The encoding of LDM is not how the rest of ISel expects a post-inc load to
// look however, so we use a pseudo here and switch it for a tLDMIA_UPD after
// ISel.
SDValue Chain = LD->getChain();
SDValue Base = LD->getBasePtr();
SDValue Ops[]= { Base, getAL(CurDAG, SDLoc(N)),
CurDAG->getRegister(0, MVT::i32), Chain };
SDNode *New = CurDAG->getMachineNode(ARM::tLDR_postidx, SDLoc(N), MVT::i32,
MVT::i32, MVT::Other, Ops);
transferMemOperands(N, New);
ReplaceNode(N, New);
return true;
}
bool ARMDAGToDAGISel::tryT2IndexedLoad(SDNode *N) {
LoadSDNode *LD = cast<LoadSDNode>(N);
ISD::MemIndexedMode AM = LD->getAddressingMode();
if (AM == ISD::UNINDEXED)
return false;
EVT LoadedVT = LD->getMemoryVT();
bool isSExtLd = LD->getExtensionType() == ISD::SEXTLOAD;
SDValue Offset;
bool isPre = (AM == ISD::PRE_INC) || (AM == ISD::PRE_DEC);
unsigned Opcode = 0;
bool Match = false;
if (<API key>(N, LD->getOffset(), Offset)) {
switch (LoadedVT.getSimpleVT().SimpleTy) {
case MVT::i32:
Opcode = isPre ? ARM::t2LDR_PRE : ARM::t2LDR_POST;
break;
case MVT::i16:
if (isSExtLd)
Opcode = isPre ? ARM::t2LDRSH_PRE : ARM::t2LDRSH_POST;
else
Opcode = isPre ? ARM::t2LDRH_PRE : ARM::t2LDRH_POST;
break;
case MVT::i8:
case MVT::i1:
if (isSExtLd)
Opcode = isPre ? ARM::t2LDRSB_PRE : ARM::t2LDRSB_POST;
else
Opcode = isPre ? ARM::t2LDRB_PRE : ARM::t2LDRB_POST;
break;
default:
return false;
}
Match = true;
}
if (Match) {
SDValue Chain = LD->getChain();
SDValue Base = LD->getBasePtr();
SDValue Ops[]= { Base, Offset, getAL(CurDAG, SDLoc(N)),
CurDAG->getRegister(0, MVT::i32), Chain };
SDNode *New = CurDAG->getMachineNode(Opcode, SDLoc(N), MVT::i32, MVT::i32,
MVT::Other, Ops);
transferMemOperands(N, New);
ReplaceNode(N, New);
return true;
}
return false;
}
Form a GPRPair pseudo register from a pair of GPR regs.
SDNode *ARMDAGToDAGISel::createGPRPairNode(EVT VT, SDValue V0, SDValue V1) {
SDLoc dl(V0.getNode());
SDValue RegClass =
CurDAG->getTargetConstant(ARM::GPRPairRegClassID, dl, MVT::i32);
SDValue SubReg0 = CurDAG->getTargetConstant(ARM::gsub_0, dl, MVT::i32);
SDValue SubReg1 = CurDAG->getTargetConstant(ARM::gsub_1, dl, MVT::i32);
const SDValue Ops[] = { RegClass, V0, SubReg0, V1, SubReg1 };
return CurDAG->getMachineNode(TargetOpcode::REG_SEQUENCE, dl, VT, Ops);
}
Form a D register from a pair of S registers.
SDNode *ARMDAGToDAGISel::createSRegPairNode(EVT VT, SDValue V0, SDValue V1) {
SDLoc dl(V0.getNode());
SDValue RegClass =
CurDAG->getTargetConstant(ARM::DPR_VFP2RegClassID, dl, MVT::i32);
SDValue SubReg0 = CurDAG->getTargetConstant(ARM::ssub_0, dl, MVT::i32);
SDValue SubReg1 = CurDAG->getTargetConstant(ARM::ssub_1, dl, MVT::i32);
const SDValue Ops[] = { RegClass, V0, SubReg0, V1, SubReg1 };
return CurDAG->getMachineNode(TargetOpcode::REG_SEQUENCE, dl, VT, Ops);
}
Form a quad register from a pair of D registers.
SDNode *ARMDAGToDAGISel::createDRegPairNode(EVT VT, SDValue V0, SDValue V1) {
SDLoc dl(V0.getNode());
SDValue RegClass = CurDAG->getTargetConstant(ARM::QPRRegClassID, dl,
MVT::i32);
SDValue SubReg0 = CurDAG->getTargetConstant(ARM::dsub_0, dl, MVT::i32);
SDValue SubReg1 = CurDAG->getTargetConstant(ARM::dsub_1, dl, MVT::i32);
const SDValue Ops[] = { RegClass, V0, SubReg0, V1, SubReg1 };
return CurDAG->getMachineNode(TargetOpcode::REG_SEQUENCE, dl, VT, Ops);
}
Form 4 consecutive D registers from a pair of Q registers.
SDNode *ARMDAGToDAGISel::createQRegPairNode(EVT VT, SDValue V0, SDValue V1) {
SDLoc dl(V0.getNode());
SDValue RegClass = CurDAG->getTargetConstant(ARM::QQPRRegClassID, dl,
MVT::i32);
SDValue SubReg0 = CurDAG->getTargetConstant(ARM::qsub_0, dl, MVT::i32);
SDValue SubReg1 = CurDAG->getTargetConstant(ARM::qsub_1, dl, MVT::i32);
const SDValue Ops[] = { RegClass, V0, SubReg0, V1, SubReg1 };
return CurDAG->getMachineNode(TargetOpcode::REG_SEQUENCE, dl, VT, Ops);
}
Form 4 consecutive S registers.
SDNode *ARMDAGToDAGISel::createQuadSRegsNode(EVT VT, SDValue V0, SDValue V1,
SDValue V2, SDValue V3) {
SDLoc dl(V0.getNode());
SDValue RegClass =
CurDAG->getTargetConstant(ARM::QPR_VFP2RegClassID, dl, MVT::i32);
SDValue SubReg0 = CurDAG->getTargetConstant(ARM::ssub_0, dl, MVT::i32);
SDValue SubReg1 = CurDAG->getTargetConstant(ARM::ssub_1, dl, MVT::i32);
SDValue SubReg2 = CurDAG->getTargetConstant(ARM::ssub_2, dl, MVT::i32);
SDValue SubReg3 = CurDAG->getTargetConstant(ARM::ssub_3, dl, MVT::i32);
const SDValue Ops[] = { RegClass, V0, SubReg0, V1, SubReg1,
V2, SubReg2, V3, SubReg3 };
return CurDAG->getMachineNode(TargetOpcode::REG_SEQUENCE, dl, VT, Ops);
}
Form 4 consecutive D registers.
SDNode *ARMDAGToDAGISel::createQuadDRegsNode(EVT VT, SDValue V0, SDValue V1,
SDValue V2, SDValue V3) {
SDLoc dl(V0.getNode());
SDValue RegClass = CurDAG->getTargetConstant(ARM::QQPRRegClassID, dl,
MVT::i32);
SDValue SubReg0 = CurDAG->getTargetConstant(ARM::dsub_0, dl, MVT::i32);
SDValue SubReg1 = CurDAG->getTargetConstant(ARM::dsub_1, dl, MVT::i32);
SDValue SubReg2 = CurDAG->getTargetConstant(ARM::dsub_2, dl, MVT::i32);
SDValue SubReg3 = CurDAG->getTargetConstant(ARM::dsub_3, dl, MVT::i32);
const SDValue Ops[] = { RegClass, V0, SubReg0, V1, SubReg1,
V2, SubReg2, V3, SubReg3 };
return CurDAG->getMachineNode(TargetOpcode::REG_SEQUENCE, dl, VT, Ops);
}
Form 4 consecutive Q registers.
SDNode *ARMDAGToDAGISel::createQuadQRegsNode(EVT VT, SDValue V0, SDValue V1,
SDValue V2, SDValue V3) {
SDLoc dl(V0.getNode());
SDValue RegClass = CurDAG->getTargetConstant(ARM::QQQQPRRegClassID, dl,
MVT::i32);
SDValue SubReg0 = CurDAG->getTargetConstant(ARM::qsub_0, dl, MVT::i32);
SDValue SubReg1 = CurDAG->getTargetConstant(ARM::qsub_1, dl, MVT::i32);
SDValue SubReg2 = CurDAG->getTargetConstant(ARM::qsub_2, dl, MVT::i32);
SDValue SubReg3 = CurDAG->getTargetConstant(ARM::qsub_3, dl, MVT::i32);
const SDValue Ops[] = { RegClass, V0, SubReg0, V1, SubReg1,
V2, SubReg2, V3, SubReg3 };
return CurDAG->getMachineNode(TargetOpcode::REG_SEQUENCE, dl, VT, Ops);
}
GetVLDSTAlign - Get the alignment (in bytes) for the alignment operand
of a NEON VLD or VST instruction. The supported values depend on the
number of registers being loaded.
SDValue ARMDAGToDAGISel::GetVLDSTAlign(SDValue Align, const SDLoc &dl,
unsigned NumVecs, bool is64BitVector) {
unsigned NumRegs = NumVecs;
if (!is64BitVector && NumVecs < 3)
NumRegs *= 2;
unsigned Alignment = cast<ConstantSDNode>(Align)->getZExtValue();
if (Alignment >= 32 && NumRegs == 4)
Alignment = 32;
else if (Alignment >= 16 && (NumRegs == 2 || NumRegs == 4))
Alignment = 16;
else if (Alignment >= 8)
Alignment = 8;
else
Alignment = 0;
return CurDAG->getTargetConstant(Alignment, dl, MVT::i32);
}
static bool isVLDfixed(unsigned Opc)
{
switch (Opc) {
default: return false;
case ARM::VLD1d8wb_fixed : return true;
case ARM::VLD1d16wb_fixed : return true;
case ARM::VLD1d64Qwb_fixed : return true;
case ARM::VLD1d32wb_fixed : return true;
case ARM::VLD1d64wb_fixed : return true;
case ARM::<API key> : return true;
case ARM::<API key> : return true;
case ARM::VLD1q8wb_fixed : return true;
case ARM::VLD1q16wb_fixed : return true;
case ARM::VLD1q32wb_fixed : return true;
case ARM::VLD1q64wb_fixed : return true;
case ARM::VLD1DUPd8wb_fixed : return true;
case ARM::VLD1DUPd16wb_fixed : return true;
case ARM::VLD1DUPd32wb_fixed : return true;
case ARM::VLD1DUPq8wb_fixed : return true;
case ARM::VLD1DUPq16wb_fixed : return true;
case ARM::VLD1DUPq32wb_fixed : return true;
case ARM::VLD2d8wb_fixed : return true;
case ARM::VLD2d16wb_fixed : return true;
case ARM::VLD2d32wb_fixed : return true;
case ARM::<API key> : return true;
case ARM::<API key> : return true;
case ARM::<API key> : return true;
case ARM::VLD2DUPd8wb_fixed : return true;
case ARM::VLD2DUPd16wb_fixed : return true;
case ARM::VLD2DUPd32wb_fixed : return true;
}
}
static bool isVSTfixed(unsigned Opc)
{
switch (Opc) {
default: return false;
case ARM::VST1d8wb_fixed : return true;
case ARM::VST1d16wb_fixed : return true;
case ARM::VST1d32wb_fixed : return true;
case ARM::VST1d64wb_fixed : return true;
case ARM::VST1q8wb_fixed : return true;
case ARM::VST1q16wb_fixed : return true;
case ARM::VST1q32wb_fixed : return true;
case ARM::VST1q64wb_fixed : return true;
case ARM::<API key> : return true;
case ARM::<API key> : return true;
case ARM::VST2d8wb_fixed : return true;
case ARM::VST2d16wb_fixed : return true;
case ARM::VST2d32wb_fixed : return true;
case ARM::<API key> : return true;
case ARM::<API key> : return true;
case ARM::<API key> : return true;
}
}
// Get the register stride update opcode of a VLD/VST instruction that
// is otherwise equivalent to the given fixed stride updating instruction.
static unsigned <API key>(unsigned Opc) {
assert((isVLDfixed(Opc) || isVSTfixed(Opc))
&& "Incorrect fixed stride updating instruction.");
switch (Opc) {
default: break;
case ARM::VLD1d8wb_fixed: return ARM::VLD1d8wb_register;
case ARM::VLD1d16wb_fixed: return ARM::VLD1d16wb_register;
case ARM::VLD1d32wb_fixed: return ARM::VLD1d32wb_register;
case ARM::VLD1d64wb_fixed: return ARM::VLD1d64wb_register;
case ARM::VLD1q8wb_fixed: return ARM::VLD1q8wb_register;
case ARM::VLD1q16wb_fixed: return ARM::VLD1q16wb_register;
case ARM::VLD1q32wb_fixed: return ARM::VLD1q32wb_register;
case ARM::VLD1q64wb_fixed: return ARM::VLD1q64wb_register;
case ARM::VLD1d64Twb_fixed: return ARM::VLD1d64Twb_register;
case ARM::VLD1d64Qwb_fixed: return ARM::VLD1d64Qwb_register;
case ARM::<API key>: return ARM::<API key>;
case ARM::<API key>: return ARM::<API key>;
case ARM::VLD1DUPd8wb_fixed : return ARM::<API key>;
case ARM::VLD1DUPd16wb_fixed : return ARM::<API key>;
case ARM::VLD1DUPd32wb_fixed : return ARM::<API key>;
case ARM::VLD1DUPq8wb_fixed : return ARM::<API key>;
case ARM::VLD1DUPq16wb_fixed : return ARM::<API key>;
case ARM::VLD1DUPq32wb_fixed : return ARM::<API key>;
case ARM::VST1d8wb_fixed: return ARM::VST1d8wb_register;
case ARM::VST1d16wb_fixed: return ARM::VST1d16wb_register;
case ARM::VST1d32wb_fixed: return ARM::VST1d32wb_register;
case ARM::VST1d64wb_fixed: return ARM::VST1d64wb_register;
case ARM::VST1q8wb_fixed: return ARM::VST1q8wb_register;
case ARM::VST1q16wb_fixed: return ARM::VST1q16wb_register;
case ARM::VST1q32wb_fixed: return ARM::VST1q32wb_register;
case ARM::VST1q64wb_fixed: return ARM::VST1q64wb_register;
case ARM::<API key>: return ARM::<API key>;
case ARM::<API key>: return ARM::<API key>;
case ARM::VLD2d8wb_fixed: return ARM::VLD2d8wb_register;
case ARM::VLD2d16wb_fixed: return ARM::VLD2d16wb_register;
case ARM::VLD2d32wb_fixed: return ARM::VLD2d32wb_register;
case ARM::<API key>: return ARM::<API key>;
case ARM::<API key>: return ARM::<API key>;
case ARM::<API key>: return ARM::<API key>;
case ARM::VST2d8wb_fixed: return ARM::VST2d8wb_register;
case ARM::VST2d16wb_fixed: return ARM::VST2d16wb_register;
case ARM::VST2d32wb_fixed: return ARM::VST2d32wb_register;
case ARM::<API key>: return ARM::<API key>;
case ARM::<API key>: return ARM::<API key>;
case ARM::<API key>: return ARM::<API key>;
case ARM::VLD2DUPd8wb_fixed: return ARM::<API key>;
case ARM::VLD2DUPd16wb_fixed: return ARM::<API key>;
case ARM::VLD2DUPd32wb_fixed: return ARM::<API key>;
}
return Opc; // If not one we handle, return it unchanged.
}
Returns true if the given increment is a Constant known to be equal to the
access size performed by a NEON load/store. This means the "[rN]!" form can
be used.
static bool isPerfectIncrement(SDValue Inc, EVT VecTy, unsigned NumVecs) {
auto C = dyn_cast<ConstantSDNode>(Inc);
return C && C->getZExtValue() == VecTy.getSizeInBits() / 8 * NumVecs;
}
void ARMDAGToDAGISel::SelectVLD(SDNode *N, bool isUpdating, unsigned NumVecs,
const uint16_t *DOpcodes,
const uint16_t *QOpcodes0,
const uint16_t *QOpcodes1) {
assert(NumVecs >= 1 && NumVecs <= 4 && "VLD NumVecs out-of-range");
SDLoc dl(N);
SDValue MemAddr, Align;
bool IsIntrinsic = !isUpdating; // By coincidence, all supported updating
// nodes are not intrinsics.
unsigned AddrOpIdx = IsIntrinsic ? 2 : 1;
if (!SelectAddrMode6(N, N->getOperand(AddrOpIdx), MemAddr, Align))
return;
SDValue Chain = N->getOperand(0);
EVT VT = N->getValueType(0);
bool is64BitVector = VT.is64BitVector();
Align = GetVLDSTAlign(Align, dl, NumVecs, is64BitVector);
unsigned OpcodeIndex;
switch (VT.getSimpleVT().SimpleTy) {
default: llvm_unreachable("unhandled vld type");
// Double-register operations:
case MVT::v8i8: OpcodeIndex = 0; break;
case MVT::v4f16:
case MVT::v4i16: OpcodeIndex = 1; break;
case MVT::v2f32:
case MVT::v2i32: OpcodeIndex = 2; break;
case MVT::v1i64: OpcodeIndex = 3; break;
// Quad-register operations:
case MVT::v16i8: OpcodeIndex = 0; break;
case MVT::v8f16:
case MVT::v8i16: OpcodeIndex = 1; break;
case MVT::v4f32:
case MVT::v4i32: OpcodeIndex = 2; break;
case MVT::v2f64:
case MVT::v2i64: OpcodeIndex = 3; break;
}
EVT ResTy;
if (NumVecs == 1)
ResTy = VT;
else {
unsigned ResTyElts = (NumVecs == 3) ? 4 : NumVecs;
if (!is64BitVector)
ResTyElts *= 2;
ResTy = EVT::getVectorVT(*CurDAG->getContext(), MVT::i64, ResTyElts);
}
std::vector<EVT> ResTys;
ResTys.push_back(ResTy);
if (isUpdating)
ResTys.push_back(MVT::i32);
ResTys.push_back(MVT::Other);
SDValue Pred = getAL(CurDAG, dl);
SDValue Reg0 = CurDAG->getRegister(0, MVT::i32);
SDNode *VLd;
SmallVector<SDValue, 7> Ops;
// Double registers and VLD1/VLD2 quad registers are directly supported.
if (is64BitVector || NumVecs <= 2) {
unsigned Opc = (is64BitVector ? DOpcodes[OpcodeIndex] :
QOpcodes0[OpcodeIndex]);
Ops.push_back(MemAddr);
Ops.push_back(Align);
if (isUpdating) {
SDValue Inc = N->getOperand(AddrOpIdx + 1);
bool IsImmUpdate = isPerfectIncrement(Inc, VT, NumVecs);
if (!IsImmUpdate) {
// We use a VLD1 for v1i64 even if the pseudo says vld2/3/4, so
// check for the opcode rather than the number of vector elements.
if (isVLDfixed(Opc))
Opc = <API key>(Opc);
Ops.push_back(Inc);
// VLD1/VLD2 fixed increment does not need Reg0 so only include it in
// the operands if not such an opcode.
} else if (!isVLDfixed(Opc))
Ops.push_back(Reg0);
}
Ops.push_back(Pred);
Ops.push_back(Reg0);
Ops.push_back(Chain);
VLd = CurDAG->getMachineNode(Opc, dl, ResTys, Ops);
} else {
// Otherwise, quad registers are loaded with two separate instructions,
// where one loads the even registers and the other loads the odd registers.
EVT AddrTy = MemAddr.getValueType();
// Load the even subregs. This is always an updating load, so that it
// provides the address to the second load for the odd subregs.
SDValue ImplDef =
SDValue(CurDAG->getMachineNode(TargetOpcode::IMPLICIT_DEF, dl, ResTy), 0);
const SDValue OpsA[] = { MemAddr, Align, Reg0, ImplDef, Pred, Reg0, Chain };
SDNode *VLdA = CurDAG->getMachineNode(QOpcodes0[OpcodeIndex], dl,
ResTy, AddrTy, MVT::Other, OpsA);
Chain = SDValue(VLdA, 2);
// Load the odd subregs.
Ops.push_back(SDValue(VLdA, 1));
Ops.push_back(Align);
if (isUpdating) {
SDValue Inc = N->getOperand(AddrOpIdx + 1);
assert(isa<ConstantSDNode>(Inc.getNode()) &&
"only constant post-increment update allowed for VLD3/4");
(void)Inc;
Ops.push_back(Reg0);
}
Ops.push_back(SDValue(VLdA, 0));
Ops.push_back(Pred);
Ops.push_back(Reg0);
Ops.push_back(Chain);
VLd = CurDAG->getMachineNode(QOpcodes1[OpcodeIndex], dl, ResTys, Ops);
}
// Transfer memoperands.
MachineMemOperand *MemOp = cast<MemIntrinsicSDNode>(N)->getMemOperand();
CurDAG->setNodeMemRefs(cast<MachineSDNode>(VLd), {MemOp});
if (NumVecs == 1) {
ReplaceNode(N, VLd);
return;
}
// Extract out the subregisters.
SDValue SuperReg = SDValue(VLd, 0);
static_assert(ARM::dsub_7 == ARM::dsub_0 + 7 &&
ARM::qsub_3 == ARM::qsub_0 + 3,
"Unexpected subreg numbering");
unsigned Sub0 = (is64BitVector ? ARM::dsub_0 : ARM::qsub_0);
for (unsigned Vec = 0; Vec < NumVecs; ++Vec)
ReplaceUses(SDValue(N, Vec),
CurDAG-><API key>(Sub0 + Vec, dl, VT, SuperReg));
ReplaceUses(SDValue(N, NumVecs), SDValue(VLd, 1));
if (isUpdating)
ReplaceUses(SDValue(N, NumVecs + 1), SDValue(VLd, 2));
CurDAG->RemoveDeadNode(N);
}
void ARMDAGToDAGISel::SelectVST(SDNode *N, bool isUpdating, unsigned NumVecs,
const uint16_t *DOpcodes,
const uint16_t *QOpcodes0,
const uint16_t *QOpcodes1) {
assert(NumVecs >= 1 && NumVecs <= 4 && "VST NumVecs out-of-range");
SDLoc dl(N);
SDValue MemAddr, Align;
bool IsIntrinsic = !isUpdating; // By coincidence, all supported updating
// nodes are not intrinsics.
unsigned AddrOpIdx = IsIntrinsic ? 2 : 1;
unsigned Vec0Idx = 3; // AddrOpIdx + (isUpdating ? 2 : 1)
if (!SelectAddrMode6(N, N->getOperand(AddrOpIdx), MemAddr, Align))
return;
MachineMemOperand *MemOp = cast<MemIntrinsicSDNode>(N)->getMemOperand();
SDValue Chain = N->getOperand(0);
EVT VT = N->getOperand(Vec0Idx).getValueType();
bool is64BitVector = VT.is64BitVector();
Align = GetVLDSTAlign(Align, dl, NumVecs, is64BitVector);
unsigned OpcodeIndex;
switch (VT.getSimpleVT().SimpleTy) {
default: llvm_unreachable("unhandled vst type");
// Double-register operations:
case MVT::v8i8: OpcodeIndex = 0; break;
case MVT::v4f16:
case MVT::v4i16: OpcodeIndex = 1; break;
case MVT::v2f32:
case MVT::v2i32: OpcodeIndex = 2; break;
case MVT::v1i64: OpcodeIndex = 3; break;
// Quad-register operations:
case MVT::v16i8: OpcodeIndex = 0; break;
case MVT::v8f16:
case MVT::v8i16: OpcodeIndex = 1; break;
case MVT::v4f32:
case MVT::v4i32: OpcodeIndex = 2; break;
case MVT::v2f64:
case MVT::v2i64: OpcodeIndex = 3; break;
}
std::vector<EVT> ResTys;
if (isUpdating)
ResTys.push_back(MVT::i32);
ResTys.push_back(MVT::Other);
SDValue Pred = getAL(CurDAG, dl);
SDValue Reg0 = CurDAG->getRegister(0, MVT::i32);
SmallVector<SDValue, 7> Ops;
// Double registers and VST1/VST2 quad registers are directly supported.
if (is64BitVector || NumVecs <= 2) {
SDValue SrcReg;
if (NumVecs == 1) {
SrcReg = N->getOperand(Vec0Idx);
} else if (is64BitVector) {
// Form a REG_SEQUENCE to force register allocation.
SDValue V0 = N->getOperand(Vec0Idx + 0);
SDValue V1 = N->getOperand(Vec0Idx + 1);
if (NumVecs == 2)
SrcReg = SDValue(createDRegPairNode(MVT::v2i64, V0, V1), 0);
else {
SDValue V2 = N->getOperand(Vec0Idx + 2);
// If it's a vst3, form a quad D-register and leave the last part as
// an undef.
SDValue V3 = (NumVecs == 3)
? SDValue(CurDAG->getMachineNode(TargetOpcode::IMPLICIT_DEF,dl,VT), 0)
: N->getOperand(Vec0Idx + 3);
SrcReg = SDValue(createQuadDRegsNode(MVT::v4i64, V0, V1, V2, V3), 0);
}
} else {
// Form a QQ register.
SDValue Q0 = N->getOperand(Vec0Idx);
SDValue Q1 = N->getOperand(Vec0Idx + 1);
SrcReg = SDValue(createQRegPairNode(MVT::v4i64, Q0, Q1), 0);
}
unsigned Opc = (is64BitVector ? DOpcodes[OpcodeIndex] :
QOpcodes0[OpcodeIndex]);
Ops.push_back(MemAddr);
Ops.push_back(Align);
if (isUpdating) {
SDValue Inc = N->getOperand(AddrOpIdx + 1);
bool IsImmUpdate = isPerfectIncrement(Inc, VT, NumVecs);
if (!IsImmUpdate) {
// We use a VST1 for v1i64 even if the pseudo says VST2/3/4, so
// check for the opcode rather than the number of vector elements.
if (isVSTfixed(Opc))
Opc = <API key>(Opc);
Ops.push_back(Inc);
}
// VST1/VST2 fixed increment does not need Reg0 so only include it in
// the operands if not such an opcode.
else if (!isVSTfixed(Opc))
Ops.push_back(Reg0);
}
Ops.push_back(SrcReg);
Ops.push_back(Pred);
Ops.push_back(Reg0);
Ops.push_back(Chain);
SDNode *VSt = CurDAG->getMachineNode(Opc, dl, ResTys, Ops);
// Transfer memoperands.
CurDAG->setNodeMemRefs(cast<MachineSDNode>(VSt), {MemOp});
ReplaceNode(N, VSt);
return;
}
// Otherwise, quad registers are stored with two separate instructions,
// where one stores the even registers and the other stores the odd registers.
// Form the QQQQ REG_SEQUENCE.
SDValue V0 = N->getOperand(Vec0Idx + 0);
SDValue V1 = N->getOperand(Vec0Idx + 1);
SDValue V2 = N->getOperand(Vec0Idx + 2);
SDValue V3 = (NumVecs == 3)
? SDValue(CurDAG->getMachineNode(TargetOpcode::IMPLICIT_DEF, dl, VT), 0)
: N->getOperand(Vec0Idx + 3);
SDValue RegSeq = SDValue(createQuadQRegsNode(MVT::v8i64, V0, V1, V2, V3), 0);
// Store the even D registers. This is always an updating store, so that it
// provides the address to the second store for the odd subregs.
const SDValue OpsA[] = { MemAddr, Align, Reg0, RegSeq, Pred, Reg0, Chain };
SDNode *VStA = CurDAG->getMachineNode(QOpcodes0[OpcodeIndex], dl,
MemAddr.getValueType(),
MVT::Other, OpsA);
CurDAG->setNodeMemRefs(cast<MachineSDNode>(VStA), {MemOp});
Chain = SDValue(VStA, 1);
// Store the odd D registers.
Ops.push_back(SDValue(VStA, 0));
Ops.push_back(Align);
if (isUpdating) {
SDValue Inc = N->getOperand(AddrOpIdx + 1);
assert(isa<ConstantSDNode>(Inc.getNode()) &&
"only constant post-increment update allowed for VST3/4");
(void)Inc;
Ops.push_back(Reg0);
}
Ops.push_back(RegSeq);
Ops.push_back(Pred);
Ops.push_back(Reg0);
Ops.push_back(Chain);
SDNode *VStB = CurDAG->getMachineNode(QOpcodes1[OpcodeIndex], dl, ResTys,
Ops);
CurDAG->setNodeMemRefs(cast<MachineSDNode>(VStB), {MemOp});
ReplaceNode(N, VStB);
}
void ARMDAGToDAGISel::SelectVLDSTLane(SDNode *N, bool IsLoad, bool isUpdating,
unsigned NumVecs,
const uint16_t *DOpcodes,
const uint16_t *QOpcodes) {
assert(NumVecs >=2 && NumVecs <= 4 && "VLDSTLane NumVecs out-of-range");
SDLoc dl(N);
SDValue MemAddr, Align;
bool IsIntrinsic = !isUpdating; // By coincidence, all supported updating
// nodes are not intrinsics.
unsigned AddrOpIdx = IsIntrinsic ? 2 : 1;
unsigned Vec0Idx = 3; // AddrOpIdx + (isUpdating ? 2 : 1)
if (!SelectAddrMode6(N, N->getOperand(AddrOpIdx), MemAddr, Align))
return;
MachineMemOperand *MemOp = cast<MemIntrinsicSDNode>(N)->getMemOperand();
SDValue Chain = N->getOperand(0);
unsigned Lane =
cast<ConstantSDNode>(N->getOperand(Vec0Idx + NumVecs))->getZExtValue();
EVT VT = N->getOperand(Vec0Idx).getValueType();
bool is64BitVector = VT.is64BitVector();
unsigned Alignment = 0;
if (NumVecs != 3) {
Alignment = cast<ConstantSDNode>(Align)->getZExtValue();
unsigned NumBytes = NumVecs * VT.getScalarSizeInBits() / 8;
if (Alignment > NumBytes)
Alignment = NumBytes;
if (Alignment < 8 && Alignment < NumBytes)
Alignment = 0;
// Alignment must be a power of two; make sure of that.
Alignment = (Alignment & -Alignment);
if (Alignment == 1)
Alignment = 0;
}
Align = CurDAG->getTargetConstant(Alignment, dl, MVT::i32);
unsigned OpcodeIndex;
switch (VT.getSimpleVT().SimpleTy) {
default: llvm_unreachable("unhandled vld/vst lane type");
// Double-register operations:
case MVT::v8i8: OpcodeIndex = 0; break;
case MVT::v4f16:
case MVT::v4i16: OpcodeIndex = 1; break;
case MVT::v2f32:
case MVT::v2i32: OpcodeIndex = 2; break;
// Quad-register operations:
case MVT::v8f16:
case MVT::v8i16: OpcodeIndex = 0; break;
case MVT::v4f32:
case MVT::v4i32: OpcodeIndex = 1; break;
}
std::vector<EVT> ResTys;
if (IsLoad) {
unsigned ResTyElts = (NumVecs == 3) ? 4 : NumVecs;
if (!is64BitVector)
ResTyElts *= 2;
ResTys.push_back(EVT::getVectorVT(*CurDAG->getContext(),
MVT::i64, ResTyElts));
}
if (isUpdating)
ResTys.push_back(MVT::i32);
ResTys.push_back(MVT::Other);
SDValue Pred = getAL(CurDAG, dl);
SDValue Reg0 = CurDAG->getRegister(0, MVT::i32);
SmallVector<SDValue, 8> Ops;
Ops.push_back(MemAddr);
Ops.push_back(Align);
if (isUpdating) {
SDValue Inc = N->getOperand(AddrOpIdx + 1);
bool IsImmUpdate =
isPerfectIncrement(Inc, VT.<API key>(), NumVecs);
Ops.push_back(IsImmUpdate ? Reg0 : Inc);
}
SDValue SuperReg;
SDValue V0 = N->getOperand(Vec0Idx + 0);
SDValue V1 = N->getOperand(Vec0Idx + 1);
if (NumVecs == 2) {
if (is64BitVector)
SuperReg = SDValue(createDRegPairNode(MVT::v2i64, V0, V1), 0);
else
SuperReg = SDValue(createQRegPairNode(MVT::v4i64, V0, V1), 0);
} else {
SDValue V2 = N->getOperand(Vec0Idx + 2);
SDValue V3 = (NumVecs == 3)
? SDValue(CurDAG->getMachineNode(TargetOpcode::IMPLICIT_DEF, dl, VT), 0)
: N->getOperand(Vec0Idx + 3);
if (is64BitVector)
SuperReg = SDValue(createQuadDRegsNode(MVT::v4i64, V0, V1, V2, V3), 0);
else
SuperReg = SDValue(createQuadQRegsNode(MVT::v8i64, V0, V1, V2, V3), 0);
}
Ops.push_back(SuperReg);
Ops.push_back(getI32Imm(Lane, dl));
Ops.push_back(Pred);
Ops.push_back(Reg0);
Ops.push_back(Chain);
unsigned Opc = (is64BitVector ? DOpcodes[OpcodeIndex] :
QOpcodes[OpcodeIndex]);
SDNode *VLdLn = CurDAG->getMachineNode(Opc, dl, ResTys, Ops);
CurDAG->setNodeMemRefs(cast<MachineSDNode>(VLdLn), {MemOp});
if (!IsLoad) {
ReplaceNode(N, VLdLn);
return;
}
// Extract the subregisters.
SuperReg = SDValue(VLdLn, 0);
static_assert(ARM::dsub_7 == ARM::dsub_0 + 7 &&
ARM::qsub_3 == ARM::qsub_0 + 3,
"Unexpected subreg numbering");
unsigned Sub0 = is64BitVector ? ARM::dsub_0 : ARM::qsub_0;
for (unsigned Vec = 0; Vec < NumVecs; ++Vec)
ReplaceUses(SDValue(N, Vec),
CurDAG-><API key>(Sub0 + Vec, dl, VT, SuperReg));
ReplaceUses(SDValue(N, NumVecs), SDValue(VLdLn, 1));
if (isUpdating)
ReplaceUses(SDValue(N, NumVecs + 1), SDValue(VLdLn, 2));
CurDAG->RemoveDeadNode(N);
}
void ARMDAGToDAGISel::SelectVLDDup(SDNode *N, bool IsIntrinsic,
bool isUpdating, unsigned NumVecs,
const uint16_t *DOpcodes,
const uint16_t *QOpcodes0,
const uint16_t *QOpcodes1) {
assert(NumVecs >= 1 && NumVecs <= 4 && "VLDDup NumVecs out-of-range");
SDLoc dl(N);
SDValue MemAddr, Align;
unsigned AddrOpIdx = IsIntrinsic ? 2 : 1;
if (!SelectAddrMode6(N, N->getOperand(AddrOpIdx), MemAddr, Align))
return;
SDValue Chain = N->getOperand(0);
EVT VT = N->getValueType(0);
bool is64BitVector = VT.is64BitVector();
unsigned Alignment = 0;
if (NumVecs != 3) {
Alignment = cast<ConstantSDNode>(Align)->getZExtValue();
unsigned NumBytes = NumVecs * VT.getScalarSizeInBits() / 8;
if (Alignment > NumBytes)
Alignment = NumBytes;
if (Alignment < 8 && Alignment < NumBytes)
Alignment = 0;
// Alignment must be a power of two; make sure of that.
Alignment = (Alignment & -Alignment);
if (Alignment == 1)
Alignment = 0;
}
Align = CurDAG->getTargetConstant(Alignment, dl, MVT::i32);
unsigned OpcodeIndex;
switch (VT.getSimpleVT().SimpleTy) {
default: llvm_unreachable("unhandled vld-dup type");
case MVT::v8i8:
case MVT::v16i8: OpcodeIndex = 0; break;
case MVT::v4i16:
case MVT::v8i16:
case MVT::v4f16:
case MVT::v8f16:
OpcodeIndex = 1; break;
case MVT::v2f32:
case MVT::v2i32:
case MVT::v4f32:
case MVT::v4i32: OpcodeIndex = 2; break;
case MVT::v1f64:
case MVT::v1i64: OpcodeIndex = 3; break;
}
unsigned ResTyElts = (NumVecs == 3) ? 4 : NumVecs;
if (!is64BitVector)
ResTyElts *= 2;
EVT ResTy = EVT::getVectorVT(*CurDAG->getContext(), MVT::i64, ResTyElts);
std::vector<EVT> ResTys;
ResTys.push_back(ResTy);
if (isUpdating)
ResTys.push_back(MVT::i32);
ResTys.push_back(MVT::Other);
SDValue Pred = getAL(CurDAG, dl);
SDValue Reg0 = CurDAG->getRegister(0, MVT::i32);
SDNode *VLdDup;
if (is64BitVector || NumVecs == 1) {
SmallVector<SDValue, 6> Ops;
Ops.push_back(MemAddr);
Ops.push_back(Align);
unsigned Opc = is64BitVector ? DOpcodes[OpcodeIndex] :
QOpcodes0[OpcodeIndex];
if (isUpdating) {
// fixed-stride update instructions don't have an explicit writeback
// operand. It's implicit in the opcode itself.
SDValue Inc = N->getOperand(2);
bool IsImmUpdate =
isPerfectIncrement(Inc, VT.<API key>(), NumVecs);
if (NumVecs <= 2 && !IsImmUpdate)
Opc = <API key>(Opc);
if (!IsImmUpdate)
Ops.push_back(Inc);
// FIXME: VLD3 and VLD4 haven't been updated to that form yet.
else if (NumVecs > 2)
Ops.push_back(Reg0);
}
Ops.push_back(Pred);
Ops.push_back(Reg0);
Ops.push_back(Chain);
VLdDup = CurDAG->getMachineNode(Opc, dl, ResTys, Ops);
} else if (NumVecs == 2) {
const SDValue OpsA[] = { MemAddr, Align, Pred, Reg0, Chain };
SDNode *VLdA = CurDAG->getMachineNode(QOpcodes0[OpcodeIndex],
dl, ResTys, OpsA);
Chain = SDValue(VLdA, 1);
const SDValue OpsB[] = { MemAddr, Align, Pred, Reg0, Chain };
VLdDup = CurDAG->getMachineNode(QOpcodes1[OpcodeIndex], dl, ResTys, OpsB);
} else {
SDValue ImplDef =
SDValue(CurDAG->getMachineNode(TargetOpcode::IMPLICIT_DEF, dl, ResTy), 0);
const SDValue OpsA[] = { MemAddr, Align, ImplDef, Pred, Reg0, Chain };
SDNode *VLdA = CurDAG->getMachineNode(QOpcodes0[OpcodeIndex],
dl, ResTys, OpsA);
SDValue SuperReg = SDValue(VLdA, 0);
Chain = SDValue(VLdA, 1);
const SDValue OpsB[] = { MemAddr, Align, SuperReg, Pred, Reg0, Chain };
VLdDup = CurDAG->getMachineNode(QOpcodes1[OpcodeIndex], dl, ResTys, OpsB);
}
// Transfer memoperands.
MachineMemOperand *MemOp = cast<MemIntrinsicSDNode>(N)->getMemOperand();
CurDAG->setNodeMemRefs(cast<MachineSDNode>(VLdDup), {MemOp});
// Extract the subregisters.
if (NumVecs == 1) {
ReplaceUses(SDValue(N, 0), SDValue(VLdDup, 0));
} else {
SDValue SuperReg = SDValue(VLdDup, 0);
static_assert(ARM::dsub_7 == ARM::dsub_0 + 7, "Unexpected subreg numbering");
unsigned SubIdx = is64BitVector ? ARM::dsub_0 : ARM::qsub_0;
for (unsigned Vec = 0; Vec != NumVecs; ++Vec) {
ReplaceUses(SDValue(N, Vec),
CurDAG-><API key>(SubIdx+Vec, dl, VT, SuperReg));
}
}
ReplaceUses(SDValue(N, NumVecs), SDValue(VLdDup, 1));
if (isUpdating)
ReplaceUses(SDValue(N, NumVecs + 1), SDValue(VLdDup, 2));
CurDAG->RemoveDeadNode(N);
}
bool ARMDAGToDAGISel::<API key>(SDNode *N, bool isSigned) {
if (!Subtarget->hasV6T2Ops())
return false;
unsigned Opc = isSigned
? (Subtarget->isThumb() ? ARM::t2SBFX : ARM::SBFX)
: (Subtarget->isThumb() ? ARM::t2UBFX : ARM::UBFX);
SDLoc dl(N);
// For unsigned extracts, check for a shift right and mask
unsigned And_imm = 0;
if (N->getOpcode() == ISD::AND) {
if (<API key>(N, ISD::AND, And_imm)) {
// The immediate is a mask of the low bits iff imm & (imm+1) == 0
if (And_imm & (And_imm + 1))
return false;
unsigned Srl_imm = 0;
if (<API key>(N->getOperand(0).getNode(), ISD::SRL,
Srl_imm)) {
assert(Srl_imm > 0 && Srl_imm < 32 && "bad amount in shift node!");
// Mask off the unnecessary bits of the AND immediate; normally
// DAGCombine will do this, but that might not happen if
// <API key> chooses a different immediate.
And_imm &= -1U >> Srl_imm;
// Note: The width operand is encoded as width-1.
unsigned Width = countTrailingOnes(And_imm) - 1;
unsigned LSB = Srl_imm;
SDValue Reg0 = CurDAG->getRegister(0, MVT::i32);
if ((LSB + Width + 1) == N->getValueType(0).getSizeInBits()) {
// It's cheaper to use a right shift to extract the top bits.
if (Subtarget->isThumb()) {
Opc = isSigned ? ARM::t2ASRri : ARM::t2LSRri;
SDValue Ops[] = { N->getOperand(0).getOperand(0),
CurDAG->getTargetConstant(LSB, dl, MVT::i32),
getAL(CurDAG, dl), Reg0, Reg0 };
CurDAG->SelectNodeTo(N, Opc, MVT::i32, Ops);
return true;
}
// ARM models shift instructions as MOVsi with shifter operand.
ARM_AM::ShiftOpc ShOpcVal = ARM_AM::getShiftOpcForNode(ISD::SRL);
SDValue ShOpc =
CurDAG->getTargetConstant(ARM_AM::getSORegOpc(ShOpcVal, LSB), dl,
MVT::i32);
SDValue Ops[] = { N->getOperand(0).getOperand(0), ShOpc,
getAL(CurDAG, dl), Reg0, Reg0 };
CurDAG->SelectNodeTo(N, ARM::MOVsi, MVT::i32, Ops);
return true;
}
assert(LSB + Width + 1 <= 32 && "Shouldn't create an invalid ubfx");
SDValue Ops[] = { N->getOperand(0).getOperand(0),
CurDAG->getTargetConstant(LSB, dl, MVT::i32),
CurDAG->getTargetConstant(Width, dl, MVT::i32),
getAL(CurDAG, dl), Reg0 };
CurDAG->SelectNodeTo(N, Opc, MVT::i32, Ops);
return true;
}
}
return false;
}
// Otherwise, we're looking for a shift of a shift
unsigned Shl_imm = 0;
if (<API key>(N->getOperand(0).getNode(), ISD::SHL, Shl_imm)) {
assert(Shl_imm > 0 && Shl_imm < 32 && "bad amount in shift node!");
unsigned Srl_imm = 0;
if (isInt32Immediate(N->getOperand(1), Srl_imm)) {
assert(Srl_imm > 0 && Srl_imm < 32 && "bad amount in shift node!");
// Note: The width operand is encoded as width-1.
unsigned Width = 32 - Srl_imm - 1;
int LSB = Srl_imm - Shl_imm;
if (LSB < 0)
return false;
SDValue Reg0 = CurDAG->getRegister(0, MVT::i32);
assert(LSB + Width + 1 <= 32 && "Shouldn't create an invalid ubfx");
SDValue Ops[] = { N->getOperand(0).getOperand(0),
CurDAG->getTargetConstant(LSB, dl, MVT::i32),
CurDAG->getTargetConstant(Width, dl, MVT::i32),
getAL(CurDAG, dl), Reg0 };
CurDAG->SelectNodeTo(N, Opc, MVT::i32, Ops);
return true;
}
}
// Or we are looking for a shift of an and, with a mask operand
if (<API key>(N->getOperand(0).getNode(), ISD::AND, And_imm) &&
isShiftedMask_32(And_imm)) {
unsigned Srl_imm = 0;
unsigned LSB = countTrailingZeros(And_imm);
// Shift must be the same as the ands lsb
if (isInt32Immediate(N->getOperand(1), Srl_imm) && Srl_imm == LSB) {
assert(Srl_imm > 0 && Srl_imm < 32 && "bad amount in shift node!");
unsigned MSB = 31 - countLeadingZeros(And_imm);
// Note: The width operand is encoded as width-1.
unsigned Width = MSB - LSB;
SDValue Reg0 = CurDAG->getRegister(0, MVT::i32);
assert(Srl_imm + Width + 1 <= 32 && "Shouldn't create an invalid ubfx");
SDValue Ops[] = { N->getOperand(0).getOperand(0),
CurDAG->getTargetConstant(Srl_imm, dl, MVT::i32),
CurDAG->getTargetConstant(Width, dl, MVT::i32),
getAL(CurDAG, dl), Reg0 };
CurDAG->SelectNodeTo(N, Opc, MVT::i32, Ops);
return true;
}
}
if (N->getOpcode() == ISD::SIGN_EXTEND_INREG) {
unsigned Width = cast<VTSDNode>(N->getOperand(1))->getVT().getSizeInBits();
unsigned LSB = 0;
if (!<API key>(N->getOperand(0).getNode(), ISD::SRL, LSB) &&
!<API key>(N->getOperand(0).getNode(), ISD::SRA, LSB))
return false;
if (LSB + Width > 32)
return false;
SDValue Reg0 = CurDAG->getRegister(0, MVT::i32);
assert(LSB + Width <= 32 && "Shouldn't create an invalid ubfx");
SDValue Ops[] = { N->getOperand(0).getOperand(0),
CurDAG->getTargetConstant(LSB, dl, MVT::i32),
CurDAG->getTargetConstant(Width - 1, dl, MVT::i32),
getAL(CurDAG, dl), Reg0 };
CurDAG->SelectNodeTo(N, Opc, MVT::i32, Ops);
return true;
}
return false;
}
Target-specific DAG combining for ISD::XOR.
Target-independent combining lowers SELECT_CC nodes of the form
select_cc setg[ge] X, 0, X, -X
select_cc setgt X, -1, X, -X
select_cc setl[te] X, 0, -X, X
select_cc setlt X, 1, -X, X
which represent Integer ABS into:
Y = sra (X, size(X)-1); xor (add (X, Y), Y)
ARM instruction selection detects the latter and matches it to
ARM::ABS or ARM::t2ABS machine node.
bool ARMDAGToDAGISel::tryABSOp(SDNode *N){
SDValue XORSrc0 = N->getOperand(0);
SDValue XORSrc1 = N->getOperand(1);
EVT VT = N->getValueType(0);
if (Subtarget->isThumb1Only())
return false;
if (XORSrc0.getOpcode() != ISD::ADD || XORSrc1.getOpcode() != ISD::SRA)
return false;
SDValue ADDSrc0 = XORSrc0.getOperand(0);
SDValue ADDSrc1 = XORSrc0.getOperand(1);
SDValue SRASrc0 = XORSrc1.getOperand(0);
SDValue SRASrc1 = XORSrc1.getOperand(1);
ConstantSDNode *SRAConstant = dyn_cast<ConstantSDNode>(SRASrc1);
EVT XType = SRASrc0.getValueType();
unsigned Size = XType.getSizeInBits() - 1;
if (ADDSrc1 == XORSrc1 && ADDSrc0 == SRASrc0 &&
XType.isInteger() && SRAConstant != nullptr &&
Size == SRAConstant->getZExtValue()) {
unsigned Opcode = Subtarget->isThumb2() ? ARM::t2ABS : ARM::ABS;
CurDAG->SelectNodeTo(N, Opcode, VT, ADDSrc0);
return true;
}
return false;
}
We've got special pseudo-instructions for these
void ARMDAGToDAGISel::SelectCMP_SWAP(SDNode *N) {
unsigned Opcode;
EVT MemTy = cast<MemSDNode>(N)->getMemoryVT();
if (MemTy == MVT::i8)
Opcode = ARM::CMP_SWAP_8;
else if (MemTy == MVT::i16)
Opcode = ARM::CMP_SWAP_16;
else if (MemTy == MVT::i32)
Opcode = ARM::CMP_SWAP_32;
else
llvm_unreachable("Unknown AtomicCmpSwap type");
SDValue Ops[] = {N->getOperand(1), N->getOperand(2), N->getOperand(3),
N->getOperand(0)};
SDNode *CmpSwap = CurDAG->getMachineNode(
Opcode, SDLoc(N),
CurDAG->getVTList(MVT::i32, MVT::i32, MVT::Other), Ops);
MachineMemOperand *MemOp = cast<MemSDNode>(N)->getMemOperand();
CurDAG->setNodeMemRefs(cast<MachineSDNode>(CmpSwap), {MemOp});
ReplaceUses(SDValue(N, 0), SDValue(CmpSwap, 0));
ReplaceUses(SDValue(N, 1), SDValue(CmpSwap, 2));
CurDAG->RemoveDeadNode(N);
}
static Optional<std::pair<unsigned, unsigned>>
<API key>(const APInt &A) {
unsigned FirstOne = A.getBitWidth() - A.countLeadingZeros() - 1;
unsigned LastOne = A.countTrailingZeros();
if (A.countPopulation() != (FirstOne - LastOne + 1))
return Optional<std::pair<unsigned,unsigned>>();
return std::make_pair(FirstOne, LastOne);
}
void ARMDAGToDAGISel::SelectCMPZ(SDNode *N, bool &SwitchEQNEToPLMI) {
assert(N->getOpcode() == ARMISD::CMPZ);
SwitchEQNEToPLMI = false;
if (!Subtarget->isThumb())
// FIXME: Work out whether it is profitable to do this in A32 mode - LSL and
// LSR don't exist as standalone instructions - they need the barrel shifter.
return;
// select (cmpz (and X, C), #0) -> (LSLS X) or (LSRS X) or (LSRS (LSLS X))
SDValue And = N->getOperand(0);
if (!And->hasOneUse())
return;
SDValue Zero = N->getOperand(1);
if (!isa<ConstantSDNode>(Zero) || !cast<ConstantSDNode>(Zero)->isNullValue() ||
And->getOpcode() != ISD::AND)
return;
SDValue X = And.getOperand(0);
auto C = dyn_cast<ConstantSDNode>(And.getOperand(1));
if (!C)
return;
auto Range = <API key>(C->getAPIntValue());
if (!Range)
return;
// There are several ways to lower this:
SDNode *NewN;
SDLoc dl(N);
auto EmitShift = [&](unsigned Opc, SDValue Src, unsigned Imm) -> SDNode* {
if (Subtarget->isThumb2()) {
Opc = (Opc == ARM::tLSLri) ? ARM::t2LSLri : ARM::t2LSRri;
SDValue Ops[] = { Src, CurDAG->getTargetConstant(Imm, dl, MVT::i32),
getAL(CurDAG, dl), CurDAG->getRegister(0, MVT::i32),
CurDAG->getRegister(0, MVT::i32) };
return CurDAG->getMachineNode(Opc, dl, MVT::i32, Ops);
} else {
SDValue Ops[] = {CurDAG->getRegister(ARM::CPSR, MVT::i32), Src,
CurDAG->getTargetConstant(Imm, dl, MVT::i32),
getAL(CurDAG, dl), CurDAG->getRegister(0, MVT::i32)};
return CurDAG->getMachineNode(Opc, dl, MVT::i32, Ops);
}
};
if (Range->second == 0) {
// 1. Mask includes the LSB -> Simply shift the top N bits off
NewN = EmitShift(ARM::tLSLri, X, 31 - Range->first);
ReplaceNode(And.getNode(), NewN);
} else if (Range->first == 31) {
// 2. Mask includes the MSB -> Simply shift the bottom N bits off
NewN = EmitShift(ARM::tLSRri, X, Range->second);
ReplaceNode(And.getNode(), NewN);
} else if (Range->first == Range->second) {
// 3. Only one bit is set. We can shift this into the sign bit and use a
// PL/MI comparison.
NewN = EmitShift(ARM::tLSLri, X, 31 - Range->first);
ReplaceNode(And.getNode(), NewN);
SwitchEQNEToPLMI = true;
} else if (!Subtarget->hasV6T2Ops()) {
// 4. Do a double shift to clear bottom and top bits, but only in
// thumb-1 mode as in thumb-2 we can use UBFX.
NewN = EmitShift(ARM::tLSLri, X, 31 - Range->first);
NewN = EmitShift(ARM::tLSRri, SDValue(NewN, 0),
Range->second + (31 - Range->first));
ReplaceNode(And.getNode(), NewN);
}
}
void ARMDAGToDAGISel::Select(SDNode *N) {
SDLoc dl(N);
if (N->isMachineOpcode()) {
N->setNodeId(-1);
return; // Already selected.
}
switch (N->getOpcode()) {
default: break;
case ISD::STORE: {
// For Thumb1, match an sp-relative store in C++. This is a little
// unfortunate, but I don't think I can make the chain check work
// otherwise. (The chain of the store has to be the same as the chain
// of the CopyFromReg, or else we can't replace the CopyFromReg with
// a direct reference to "SP".)
// This is only necessary on Thumb1 because Thumb1 sp-relative stores use
// a different addressing mode from other four-byte stores.
// This pattern usually comes up with call arguments.
StoreSDNode *ST = cast<StoreSDNode>(N);
SDValue Ptr = ST->getBasePtr();
if (Subtarget->isThumb1Only() && ST->isUnindexed()) {
int RHSC = 0;
if (Ptr.getOpcode() == ISD::ADD &&
<API key>(Ptr.getOperand(1), /*Scale=*/4, 0, 256, RHSC))
Ptr = Ptr.getOperand(0);
if (Ptr.getOpcode() == ISD::CopyFromReg &&
cast<RegisterSDNode>(Ptr.getOperand(1))->getReg() == ARM::SP &&
Ptr.getOperand(0) == ST->getChain()) {
SDValue Ops[] = {ST->getValue(),
CurDAG->getRegister(ARM::SP, MVT::i32),
CurDAG->getTargetConstant(RHSC, dl, MVT::i32),
getAL(CurDAG, dl),
CurDAG->getRegister(0, MVT::i32),
ST->getChain()};
MachineSDNode *ResNode =
CurDAG->getMachineNode(ARM::tSTRspi, dl, MVT::Other, Ops);
MachineMemOperand *MemOp = ST->getMemOperand();
CurDAG->setNodeMemRefs(cast<MachineSDNode>(ResNode), {MemOp});
ReplaceNode(N, ResNode);
return;
}
}
break;
}
case ISD::WRITE_REGISTER:
if (tryWriteRegister(N))
return;
break;
case ISD::READ_REGISTER:
if (tryReadRegister(N))
return;
break;
case ISD::INLINEASM:
case ISD::INLINEASM_BR:
if (tryInlineAsm(N))
return;
break;
case ISD::XOR:
// Select special operations if XOR node forms integer ABS pattern
if (tryABSOp(N))
return;
// Other cases are autogenerated.
break;
case ISD::Constant: {
unsigned Val = cast<ConstantSDNode>(N)->getZExtValue();
// If we can't materialize the constant we need to use a literal pool
if (<API key>(Val) > 2) {
SDValue CPIdx = CurDAG-><API key>(
ConstantInt::get(Type::getInt32Ty(*CurDAG->getContext()), Val),
TLI->getPointerTy(CurDAG->getDataLayout()));
SDNode *ResNode;
if (Subtarget->isThumb()) {
SDValue Ops[] = {
CPIdx,
getAL(CurDAG, dl),
CurDAG->getRegister(0, MVT::i32),
CurDAG->getEntryNode()
};
ResNode = CurDAG->getMachineNode(ARM::tLDRpci, dl, MVT::i32, MVT::Other,
Ops);
} else {
SDValue Ops[] = {
CPIdx,
CurDAG->getTargetConstant(0, dl, MVT::i32),
getAL(CurDAG, dl),
CurDAG->getRegister(0, MVT::i32),
CurDAG->getEntryNode()
};
ResNode = CurDAG->getMachineNode(ARM::LDRcp, dl, MVT::i32, MVT::Other,
Ops);
}
// Annotate the Node with memory operand information so that MachineInstr
// queries work properly. This e.g. gives the register allocation the
// required information for rematerialization.
MachineFunction& MF = CurDAG->getMachineFunction();
MachineMemOperand *MemOp =
MF.<API key>(MachinePointerInfo::getConstantPool(MF),
MachineMemOperand::MOLoad, 4, 4);
CurDAG->setNodeMemRefs(cast<MachineSDNode>(ResNode), {MemOp});
ReplaceNode(N, ResNode);
return;
}
// Other cases are autogenerated.
break;
}
case ISD::FrameIndex: {
// Selects to ADDri FI, 0 which in turn will become ADDri SP, imm.
int FI = cast<FrameIndexSDNode>(N)->getIndex();
SDValue TFI = CurDAG->getTargetFrameIndex(
FI, TLI->getPointerTy(CurDAG->getDataLayout()));
if (Subtarget->isThumb1Only()) {
// Set the alignment of the frame object to 4, to avoid having to generate
// more than one ADD
MachineFrameInfo &MFI = MF->getFrameInfo();
if (MFI.getObjectAlignment(FI) < 4)
MFI.setObjectAlignment(FI, 4);
CurDAG->SelectNodeTo(N, ARM::tADDframe, MVT::i32, TFI,
CurDAG->getTargetConstant(0, dl, MVT::i32));
return;
} else {
unsigned Opc = ((Subtarget->isThumb() && Subtarget->hasThumb2()) ?
ARM::t2ADDri : ARM::ADDri);
SDValue Ops[] = { TFI, CurDAG->getTargetConstant(0, dl, MVT::i32),
getAL(CurDAG, dl), CurDAG->getRegister(0, MVT::i32),
CurDAG->getRegister(0, MVT::i32) };
CurDAG->SelectNodeTo(N, Opc, MVT::i32, Ops);
return;
}
}
case ISD::SRL:
if (<API key>(N, false))
return;
break;
case ISD::SIGN_EXTEND_INREG:
case ISD::SRA:
if (<API key>(N, true))
return;
break;
case ISD::MUL:
if (Subtarget->isThumb1Only())
break;
if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(N->getOperand(1))) {
unsigned RHSV = C->getZExtValue();
if (!RHSV) break;
if (isPowerOf2_32(RHSV-1)) { // 2^n+1?
unsigned ShImm = Log2_32(RHSV-1);
if (ShImm >= 32)
break;
SDValue V = N->getOperand(0);
ShImm = ARM_AM::getSORegOpc(ARM_AM::lsl, ShImm);
SDValue ShImmOp = CurDAG->getTargetConstant(ShImm, dl, MVT::i32);
SDValue Reg0 = CurDAG->getRegister(0, MVT::i32);
if (Subtarget->isThumb()) {
SDValue Ops[] = { V, V, ShImmOp, getAL(CurDAG, dl), Reg0, Reg0 };
CurDAG->SelectNodeTo(N, ARM::t2ADDrs, MVT::i32, Ops);
return;
} else {
SDValue Ops[] = { V, V, Reg0, ShImmOp, getAL(CurDAG, dl), Reg0,
Reg0 };
CurDAG->SelectNodeTo(N, ARM::ADDrsi, MVT::i32, Ops);
return;
}
}
if (isPowerOf2_32(RHSV+1)) { // 2^n-1?
unsigned ShImm = Log2_32(RHSV+1);
if (ShImm >= 32)
break;
SDValue V = N->getOperand(0);
ShImm = ARM_AM::getSORegOpc(ARM_AM::lsl, ShImm);
SDValue ShImmOp = CurDAG->getTargetConstant(ShImm, dl, MVT::i32);
SDValue Reg0 = CurDAG->getRegister(0, MVT::i32);
if (Subtarget->isThumb()) {
SDValue Ops[] = { V, V, ShImmOp, getAL(CurDAG, dl), Reg0, Reg0 };
CurDAG->SelectNodeTo(N, ARM::t2RSBrs, MVT::i32, Ops);
return;
} else {
SDValue Ops[] = { V, V, Reg0, ShImmOp, getAL(CurDAG, dl), Reg0,
Reg0 };
CurDAG->SelectNodeTo(N, ARM::RSBrsi, MVT::i32, Ops);
return;
}
}
}
break;
case ISD::AND: {
// Check for unsigned bitfield extract
if (<API key>(N, false))
return;
// If an immediate is used in an AND node, it is possible that the immediate
// can be more optimally materialized when negated. If this is the case we
// can negate the immediate and use a BIC instead.
auto *N1C = dyn_cast<ConstantSDNode>(N->getOperand(1));
if (N1C && N1C->hasOneUse() && Subtarget->isThumb()) {
uint32_t Imm = (uint32_t) N1C->getZExtValue();
// In Thumb2 mode, an AND can take a 12-bit immediate. If this
// immediate can be negated and fit in the immediate operand of
// a t2BIC, don't do any manual transform here as this can be
// handled by the generic ISel machinery.
bool <API key> =
Subtarget->hasThumb2() && (is_t2_so_imm(Imm) || is_t2_so_imm_not(Imm));
if (!<API key> &&
<API key>(Imm) >
<API key>(~Imm)) {
// The current immediate costs more to materialize than a negated
// immediate, so negate the immediate and use a BIC.
SDValue NewImm =
CurDAG->getConstant(~N1C->getZExtValue(), dl, MVT::i32);
// If the new constant didn't exist before, reposition it in the topological
// ordering so it is just before N. Otherwise, don't touch its location.
if (NewImm->getNodeId() == -1)
CurDAG->RepositionNode(N->getIterator(), NewImm.getNode());
if (!Subtarget->hasThumb2()) {
SDValue Ops[] = {CurDAG->getRegister(ARM::CPSR, MVT::i32),
N->getOperand(0), NewImm, getAL(CurDAG, dl),
CurDAG->getRegister(0, MVT::i32)};
ReplaceNode(N, CurDAG->getMachineNode(ARM::tBIC, dl, MVT::i32, Ops));
return;
} else {
SDValue Ops[] = {N->getOperand(0), NewImm, getAL(CurDAG, dl),
CurDAG->getRegister(0, MVT::i32),
CurDAG->getRegister(0, MVT::i32)};
ReplaceNode(N,
CurDAG->getMachineNode(ARM::t2BICrr, dl, MVT::i32, Ops));
return;
}
}
}
// (and (or x, c2), c1) and top 16-bits of c1 and c2 match, lower 16-bits
// of c1 are 0xffff, and lower 16-bit of c2 are 0. That is, the top 16-bits
// are entirely contributed by c2 and lower 16-bits are entirely contributed
// by x. That's equal to (or (and x, 0xffff), (and c1, 0xffff0000)).
// Select it to: "movt x, ((c1 & 0xffff) >> 16)
EVT VT = N->getValueType(0);
if (VT != MVT::i32)
break;
unsigned Opc = (Subtarget->isThumb() && Subtarget->hasThumb2())
? ARM::t2MOVTi16
: (Subtarget->hasV6T2Ops() ? ARM::MOVTi16 : 0);
if (!Opc)
break;
SDValue N0 = N->getOperand(0), N1 = N->getOperand(1);
N1C = dyn_cast<ConstantSDNode>(N1);
if (!N1C)
break;
if (N0.getOpcode() == ISD::OR && N0.getNode()->hasOneUse()) {
SDValue N2 = N0.getOperand(1);
ConstantSDNode *N2C = dyn_cast<ConstantSDNode>(N2);
if (!N2C)
break;
unsigned N1CVal = N1C->getZExtValue();
unsigned N2CVal = N2C->getZExtValue();
if ((N1CVal & 0xffff0000U) == (N2CVal & 0xffff0000U) &&
(N1CVal & 0xffffU) == 0xffffU &&
(N2CVal & 0xffffU) == 0x0U) {
SDValue Imm16 = CurDAG->getTargetConstant((N2CVal & 0xFFFF0000U) >> 16,
dl, MVT::i32);
SDValue Ops[] = { N0.getOperand(0), Imm16,
getAL(CurDAG, dl), CurDAG->getRegister(0, MVT::i32) };
ReplaceNode(N, CurDAG->getMachineNode(Opc, dl, VT, Ops));
return;
}
}
break;
}
case ARMISD::UMAAL: {
unsigned Opc = Subtarget->isThumb() ? ARM::t2UMAAL : ARM::UMAAL;
SDValue Ops[] = { N->getOperand(0), N->getOperand(1),
N->getOperand(2), N->getOperand(3),
getAL(CurDAG, dl),
CurDAG->getRegister(0, MVT::i32) };
ReplaceNode(N, CurDAG->getMachineNode(Opc, dl, MVT::i32, MVT::i32, Ops));
return;
}
case ARMISD::UMLAL:{
if (Subtarget->isThumb()) {
SDValue Ops[] = { N->getOperand(0), N->getOperand(1), N->getOperand(2),
N->getOperand(3), getAL(CurDAG, dl),
CurDAG->getRegister(0, MVT::i32)};
ReplaceNode(
N, CurDAG->getMachineNode(ARM::t2UMLAL, dl, MVT::i32, MVT::i32, Ops));
return;
}else{
SDValue Ops[] = { N->getOperand(0), N->getOperand(1), N->getOperand(2),
N->getOperand(3), getAL(CurDAG, dl),
CurDAG->getRegister(0, MVT::i32),
CurDAG->getRegister(0, MVT::i32) };
ReplaceNode(N, CurDAG->getMachineNode(
Subtarget->hasV6Ops() ? ARM::UMLAL : ARM::UMLALv5, dl,
MVT::i32, MVT::i32, Ops));
return;
}
}
case ARMISD::SMLAL:{
if (Subtarget->isThumb()) {
SDValue Ops[] = { N->getOperand(0), N->getOperand(1), N->getOperand(2),
N->getOperand(3), getAL(CurDAG, dl),
CurDAG->getRegister(0, MVT::i32)};
ReplaceNode(
N, CurDAG->getMachineNode(ARM::t2SMLAL, dl, MVT::i32, MVT::i32, Ops));
return;
}else{
SDValue Ops[] = { N->getOperand(0), N->getOperand(1), N->getOperand(2),
N->getOperand(3), getAL(CurDAG, dl),
CurDAG->getRegister(0, MVT::i32),
CurDAG->getRegister(0, MVT::i32) };
ReplaceNode(N, CurDAG->getMachineNode(
Subtarget->hasV6Ops() ? ARM::SMLAL : ARM::SMLALv5, dl,
MVT::i32, MVT::i32, Ops));
return;
}
}
case ARMISD::SUBE: {
if (!Subtarget->hasV6Ops() || !Subtarget->hasDSP())
break;
// Look for a pattern to match SMMLS
// (sube a, (smul_loHi a, b), (subc 0, (smul_LOhi(a, b))))
if (N->getOperand(1).getOpcode() != ISD::SMUL_LOHI ||
N->getOperand(2).getOpcode() != ARMISD::SUBC ||
!SDValue(N, 1).use_empty())
break;
if (Subtarget->isThumb())
assert(Subtarget->hasThumb2() &&
"This pattern should not be generated for Thumb");
SDValue SmulLoHi = N->getOperand(1);
SDValue Subc = N->getOperand(2);
auto *Zero = dyn_cast<ConstantSDNode>(Subc.getOperand(0));
if (!Zero || Zero->getZExtValue() != 0 ||
Subc.getOperand(1) != SmulLoHi.getValue(0) ||
N->getOperand(1) != SmulLoHi.getValue(1) ||
N->getOperand(2) != Subc.getValue(1))
break;
unsigned Opc = Subtarget->isThumb2() ? ARM::t2SMMLS : ARM::SMMLS;
SDValue Ops[] = { SmulLoHi.getOperand(0), SmulLoHi.getOperand(1),
N->getOperand(0), getAL(CurDAG, dl),
CurDAG->getRegister(0, MVT::i32) };
ReplaceNode(N, CurDAG->getMachineNode(Opc, dl, MVT::i32, Ops));
return;
}
case ISD::LOAD: {
if (Subtarget->isThumb() && Subtarget->hasThumb2()) {
if (tryT2IndexedLoad(N))
return;
} else if (Subtarget->isThumb()) {
if (tryT1IndexedLoad(N))
return;
} else if (tryARMIndexedLoad(N))
return;
// Other cases are autogenerated.
break;
}
case ARMISD::BRCOND: {
// Pattern: (ARMbrcond:void (bb:Other):$dst, (imm:i32):$cc)
// Emits: (Bcc:void (bb:Other):$dst, (imm:i32):$cc)
// Pattern complexity = 6 cost = 1 size = 0
// Pattern: (ARMbrcond:void (bb:Other):$dst, (imm:i32):$cc)
// Emits: (tBcc:void (bb:Other):$dst, (imm:i32):$cc)
// Pattern complexity = 6 cost = 1 size = 0
// Pattern: (ARMbrcond:void (bb:Other):$dst, (imm:i32):$cc)
// Emits: (t2Bcc:void (bb:Other):$dst, (imm:i32):$cc)
// Pattern complexity = 6 cost = 1 size = 0
unsigned Opc = Subtarget->isThumb() ?
((Subtarget->hasThumb2()) ? ARM::t2Bcc : ARM::tBcc) : ARM::Bcc;
SDValue Chain = N->getOperand(0);
SDValue N1 = N->getOperand(1);
SDValue N2 = N->getOperand(2);
SDValue N3 = N->getOperand(3);
SDValue InFlag = N->getOperand(4);
assert(N1.getOpcode() == ISD::BasicBlock);
assert(N2.getOpcode() == ISD::Constant);
assert(N3.getOpcode() == ISD::Register);
unsigned CC = (unsigned) cast<ConstantSDNode>(N2)->getZExtValue();
if (InFlag.getOpcode() == ARMISD::CMPZ) {
bool SwitchEQNEToPLMI;
SelectCMPZ(InFlag.getNode(), SwitchEQNEToPLMI);
InFlag = N->getOperand(4);
if (SwitchEQNEToPLMI) {
switch ((ARMCC::CondCodes)CC) {
default: llvm_unreachable("CMPZ must be either NE or EQ!");
case ARMCC::NE:
CC = (unsigned)ARMCC::MI;
break;
case ARMCC::EQ:
CC = (unsigned)ARMCC::PL;
break;
}
}
}
SDValue Tmp2 = CurDAG->getTargetConstant(CC, dl, MVT::i32);
SDValue Ops[] = { N1, Tmp2, N3, Chain, InFlag };
SDNode *ResNode = CurDAG->getMachineNode(Opc, dl, MVT::Other,
MVT::Glue, Ops);
Chain = SDValue(ResNode, 0);
if (N->getNumValues() == 2) {
InFlag = SDValue(ResNode, 1);
ReplaceUses(SDValue(N, 1), InFlag);
}
ReplaceUses(SDValue(N, 0),
SDValue(Chain.getNode(), Chain.getResNo()));
CurDAG->RemoveDeadNode(N);
return;
}
case ARMISD::CMPZ: {
// select (CMPZ X, #-C) -> (CMPZ (ADDS X, #C), #0)
// This allows us to avoid materializing the expensive negative constant.
// The CMPZ #0 is useless and will be peepholed away but we need to keep it
// for its glue output.
SDValue X = N->getOperand(0);
auto *C = dyn_cast<ConstantSDNode>(N->getOperand(1).getNode());
if (C && C->getSExtValue() < 0 && Subtarget->isThumb()) {
int64_t Addend = -C->getSExtValue();
SDNode *Add = nullptr;
// ADDS can be better than CMN if the immediate fits in a
// 16-bit ADDS, which means either [0,256) for tADDi8 or [0,8) for tADDi3.
// Outside that range we can just use a CMN which is 32-bit but has a
// 12-bit immediate range.
if (Addend < 1<<8) {
if (Subtarget->isThumb2()) {
SDValue Ops[] = { X, CurDAG->getTargetConstant(Addend, dl, MVT::i32),
getAL(CurDAG, dl), CurDAG->getRegister(0, MVT::i32),
CurDAG->getRegister(0, MVT::i32) };
Add = CurDAG->getMachineNode(ARM::t2ADDri, dl, MVT::i32, Ops);
} else {
unsigned Opc = (Addend < 1<<3) ? ARM::tADDi3 : ARM::tADDi8;
SDValue Ops[] = {CurDAG->getRegister(ARM::CPSR, MVT::i32), X,
CurDAG->getTargetConstant(Addend, dl, MVT::i32),
getAL(CurDAG, dl), CurDAG->getRegister(0, MVT::i32)};
Add = CurDAG->getMachineNode(Opc, dl, MVT::i32, Ops);
}
}
if (Add) {
SDValue Ops2[] = {SDValue(Add, 0), CurDAG->getConstant(0, dl, MVT::i32)};
CurDAG->MorphNodeTo(N, ARMISD::CMPZ, CurDAG->getVTList(MVT::Glue), Ops2);
}
}
// Other cases are autogenerated.
break;
}
case ARMISD::CMOV: {
SDValue InFlag = N->getOperand(4);
if (InFlag.getOpcode() == ARMISD::CMPZ) {
bool SwitchEQNEToPLMI;
SelectCMPZ(InFlag.getNode(), SwitchEQNEToPLMI);
if (SwitchEQNEToPLMI) {
SDValue ARMcc = N->getOperand(2);
ARMCC::CondCodes CC =
(ARMCC::CondCodes)cast<ConstantSDNode>(ARMcc)->getZExtValue();
switch (CC) {
default: llvm_unreachable("CMPZ must be either NE or EQ!");
case ARMCC::NE:
CC = ARMCC::MI;
break;
case ARMCC::EQ:
CC = ARMCC::PL;
break;
}
SDValue NewARMcc = CurDAG->getConstant((unsigned)CC, dl, MVT::i32);
SDValue Ops[] = {N->getOperand(0), N->getOperand(1), NewARMcc,
N->getOperand(3), N->getOperand(4)};
CurDAG->MorphNodeTo(N, ARMISD::CMOV, N->getVTList(), Ops);
}
}
// Other cases are autogenerated.
break;
}
case ARMISD::VZIP: {
unsigned Opc = 0;
EVT VT = N->getValueType(0);
switch (VT.getSimpleVT().SimpleTy) {
default: return;
case MVT::v8i8: Opc = ARM::VZIPd8; break;
case MVT::v4f16:
case MVT::v4i16: Opc = ARM::VZIPd16; break;
case MVT::v2f32:
// vzip.32 Dd, Dm is a pseudo-instruction expanded to vtrn.32 Dd, Dm.
case MVT::v2i32: Opc = ARM::VTRNd32; break;
case MVT::v16i8: Opc = ARM::VZIPq8; break;
case MVT::v8f16:
case MVT::v8i16: Opc = ARM::VZIPq16; break;
case MVT::v4f32:
case MVT::v4i32: Opc = ARM::VZIPq32; break;
}
SDValue Pred = getAL(CurDAG, dl);
SDValue PredReg = CurDAG->getRegister(0, MVT::i32);
SDValue Ops[] = { N->getOperand(0), N->getOperand(1), Pred, PredReg };
ReplaceNode(N, CurDAG->getMachineNode(Opc, dl, VT, VT, Ops));
return;
}
case ARMISD::VUZP: {
unsigned Opc = 0;
EVT VT = N->getValueType(0);
switch (VT.getSimpleVT().SimpleTy) {
default: return;
case MVT::v8i8: Opc = ARM::VUZPd8; break;
case MVT::v4f16:
case MVT::v4i16: Opc = ARM::VUZPd16; break;
case MVT::v2f32:
// vuzp.32 Dd, Dm is a pseudo-instruction expanded to vtrn.32 Dd, Dm.
case MVT::v2i32: Opc = ARM::VTRNd32; break;
case MVT::v16i8: Opc = ARM::VUZPq8; break;
case MVT::v8f16:
case MVT::v8i16: Opc = ARM::VUZPq16; break;
case MVT::v4f32:
case MVT::v4i32: Opc = ARM::VUZPq32; break;
}
SDValue Pred = getAL(CurDAG, dl);
SDValue PredReg = CurDAG->getRegister(0, MVT::i32);
SDValue Ops[] = { N->getOperand(0), N->getOperand(1), Pred, PredReg };
ReplaceNode(N, CurDAG->getMachineNode(Opc, dl, VT, VT, Ops));
return;
}
case ARMISD::VTRN: {
unsigned Opc = 0;
EVT VT = N->getValueType(0);
switch (VT.getSimpleVT().SimpleTy) {
default: return;
case MVT::v8i8: Opc = ARM::VTRNd8; break;
case MVT::v4f16:
case MVT::v4i16: Opc = ARM::VTRNd16; break;
case MVT::v2f32:
case MVT::v2i32: Opc = ARM::VTRNd32; break;
case MVT::v16i8: Opc = ARM::VTRNq8; break;
case MVT::v8f16:
case MVT::v8i16: Opc = ARM::VTRNq16; break;
case MVT::v4f32:
case MVT::v4i32: Opc = ARM::VTRNq32; break;
}
SDValue Pred = getAL(CurDAG, dl);
SDValue PredReg = CurDAG->getRegister(0, MVT::i32);
SDValue Ops[] = { N->getOperand(0), N->getOperand(1), Pred, PredReg };
ReplaceNode(N, CurDAG->getMachineNode(Opc, dl, VT, VT, Ops));
return;
}
case ARMISD::BUILD_VECTOR: {
EVT VecVT = N->getValueType(0);
EVT EltVT = VecVT.<API key>();
unsigned NumElts = VecVT.<API key>();
if (EltVT == MVT::f64) {
assert(NumElts == 2 && "unexpected type for BUILD_VECTOR");
ReplaceNode(
N, createDRegPairNode(VecVT, N->getOperand(0), N->getOperand(1)));
return;
}
assert(EltVT == MVT::f32 && "unexpected type for BUILD_VECTOR");
if (NumElts == 2) {
ReplaceNode(
N, createSRegPairNode(VecVT, N->getOperand(0), N->getOperand(1)));
return;
}
assert(NumElts == 4 && "unexpected type for BUILD_VECTOR");
ReplaceNode(N,
createQuadSRegsNode(VecVT, N->getOperand(0), N->getOperand(1),
N->getOperand(2), N->getOperand(3)));
return;
}
case ARMISD::VLD1DUP: {
static const uint16_t DOpcodes[] = { ARM::VLD1DUPd8, ARM::VLD1DUPd16,
ARM::VLD1DUPd32 };
static const uint16_t QOpcodes[] = { ARM::VLD1DUPq8, ARM::VLD1DUPq16,
ARM::VLD1DUPq32 };
SelectVLDDup(N, /* IsIntrinsic= */ false, false, 1, DOpcodes, QOpcodes);
return;
}
case ARMISD::VLD2DUP: {
static const uint16_t Opcodes[] = { ARM::VLD2DUPd8, ARM::VLD2DUPd16,
ARM::VLD2DUPd32 };
SelectVLDDup(N, /* IsIntrinsic= */ false, false, 2, Opcodes);
return;
}
case ARMISD::VLD3DUP: {
static const uint16_t Opcodes[] = { ARM::VLD3DUPd8Pseudo,
ARM::VLD3DUPd16Pseudo,
ARM::VLD3DUPd32Pseudo };
SelectVLDDup(N, /* IsIntrinsic= */ false, false, 3, Opcodes);
return;
}
case ARMISD::VLD4DUP: {
static const uint16_t Opcodes[] = { ARM::VLD4DUPd8Pseudo,
ARM::VLD4DUPd16Pseudo,
ARM::VLD4DUPd32Pseudo };
SelectVLDDup(N, /* IsIntrinsic= */ false, false, 4, Opcodes);
return;
}
case ARMISD::VLD1DUP_UPD: {
static const uint16_t DOpcodes[] = { ARM::VLD1DUPd8wb_fixed,
ARM::VLD1DUPd16wb_fixed,
ARM::VLD1DUPd32wb_fixed };
static const uint16_t QOpcodes[] = { ARM::VLD1DUPq8wb_fixed,
ARM::VLD1DUPq16wb_fixed,
ARM::VLD1DUPq32wb_fixed };
SelectVLDDup(N, /* IsIntrinsic= */ false, true, 1, DOpcodes, QOpcodes);
return;
}
case ARMISD::VLD2DUP_UPD: {
static const uint16_t Opcodes[] = { ARM::VLD2DUPd8wb_fixed,
ARM::VLD2DUPd16wb_fixed,
ARM::VLD2DUPd32wb_fixed };
SelectVLDDup(N, /* IsIntrinsic= */ false, true, 2, Opcodes);
return;
}
case ARMISD::VLD3DUP_UPD: {
static const uint16_t Opcodes[] = { ARM::VLD3DUPd8Pseudo_UPD,
ARM::<API key>,
ARM::<API key> };
SelectVLDDup(N, /* IsIntrinsic= */ false, true, 3, Opcodes);
return;
}
case ARMISD::VLD4DUP_UPD: {
static const uint16_t Opcodes[] = { ARM::VLD4DUPd8Pseudo_UPD,
ARM::<API key>,
ARM::<API key> };
SelectVLDDup(N, /* IsIntrinsic= */ false, true, 4, Opcodes);
return;
}
case ARMISD::VLD1_UPD: {
static const uint16_t DOpcodes[] = { ARM::VLD1d8wb_fixed,
ARM::VLD1d16wb_fixed,
ARM::VLD1d32wb_fixed,
ARM::VLD1d64wb_fixed };
static const uint16_t QOpcodes[] = { ARM::VLD1q8wb_fixed,
ARM::VLD1q16wb_fixed,
ARM::VLD1q32wb_fixed,
ARM::VLD1q64wb_fixed };
SelectVLD(N, true, 1, DOpcodes, QOpcodes, nullptr);
return;
}
case ARMISD::VLD2_UPD: {
static const uint16_t DOpcodes[] = { ARM::VLD2d8wb_fixed,
ARM::VLD2d16wb_fixed,
ARM::VLD2d32wb_fixed,
ARM::VLD1q64wb_fixed};
static const uint16_t QOpcodes[] = { ARM::<API key>,
ARM::<API key>,
ARM::<API key> };
SelectVLD(N, true, 2, DOpcodes, QOpcodes, nullptr);
return;
}
case ARMISD::VLD3_UPD: {
static const uint16_t DOpcodes[] = { ARM::VLD3d8Pseudo_UPD,
ARM::VLD3d16Pseudo_UPD,
ARM::VLD3d32Pseudo_UPD,
ARM::<API key>};
static const uint16_t QOpcodes0[] = { ARM::VLD3q8Pseudo_UPD,
ARM::VLD3q16Pseudo_UPD,
ARM::VLD3q32Pseudo_UPD };
static const uint16_t QOpcodes1[] = { ARM::VLD3q8oddPseudo_UPD,
ARM::<API key>,
ARM::<API key> };
SelectVLD(N, true, 3, DOpcodes, QOpcodes0, QOpcodes1);
return;
}
case ARMISD::VLD4_UPD: {
static const uint16_t DOpcodes[] = { ARM::VLD4d8Pseudo_UPD,
ARM::VLD4d16Pseudo_UPD,
ARM::VLD4d32Pseudo_UPD,
ARM::<API key>};
static const uint16_t QOpcodes0[] = { ARM::VLD4q8Pseudo_UPD,
ARM::VLD4q16Pseudo_UPD,
ARM::VLD4q32Pseudo_UPD };
static const uint16_t QOpcodes1[] = { ARM::VLD4q8oddPseudo_UPD,
ARM::<API key>,
ARM::<API key> };
SelectVLD(N, true, 4, DOpcodes, QOpcodes0, QOpcodes1);
return;
}
case ARMISD::VLD2LN_UPD: {
static const uint16_t DOpcodes[] = { ARM::VLD2LNd8Pseudo_UPD,
ARM::VLD2LNd16Pseudo_UPD,
ARM::VLD2LNd32Pseudo_UPD };
static const uint16_t QOpcodes[] = { ARM::VLD2LNq16Pseudo_UPD,
ARM::VLD2LNq32Pseudo_UPD };
SelectVLDSTLane(N, true, true, 2, DOpcodes, QOpcodes);
return;
}
case ARMISD::VLD3LN_UPD: {
static const uint16_t DOpcodes[] = { ARM::VLD3LNd8Pseudo_UPD,
ARM::VLD3LNd16Pseudo_UPD,
ARM::VLD3LNd32Pseudo_UPD };
static const uint16_t QOpcodes[] = { ARM::VLD3LNq16Pseudo_UPD,
ARM::VLD3LNq32Pseudo_UPD };
SelectVLDSTLane(N, true, true, 3, DOpcodes, QOpcodes);
return;
}
case ARMISD::VLD4LN_UPD: {
static const uint16_t DOpcodes[] = { ARM::VLD4LNd8Pseudo_UPD,
ARM::VLD4LNd16Pseudo_UPD,
ARM::VLD4LNd32Pseudo_UPD };
static const uint16_t QOpcodes[] = { ARM::VLD4LNq16Pseudo_UPD,
ARM::VLD4LNq32Pseudo_UPD };
SelectVLDSTLane(N, true, true, 4, DOpcodes, QOpcodes);
return;
}
case ARMISD::VST1_UPD: {
static const uint16_t DOpcodes[] = { ARM::VST1d8wb_fixed,
ARM::VST1d16wb_fixed,
ARM::VST1d32wb_fixed,
ARM::VST1d64wb_fixed };
static const uint16_t QOpcodes[] = { ARM::VST1q8wb_fixed,
ARM::VST1q16wb_fixed,
ARM::VST1q32wb_fixed,
ARM::VST1q64wb_fixed };
SelectVST(N, true, 1, DOpcodes, QOpcodes, nullptr);
return;
}
case ARMISD::VST2_UPD: {
static const uint16_t DOpcodes[] = { ARM::VST2d8wb_fixed,
ARM::VST2d16wb_fixed,
ARM::VST2d32wb_fixed,
ARM::VST1q64wb_fixed};
static const uint16_t QOpcodes[] = { ARM::<API key>,
ARM::<API key>,
ARM::<API key> };
SelectVST(N, true, 2, DOpcodes, QOpcodes, nullptr);
return;
}
case ARMISD::VST3_UPD: {
static const uint16_t DOpcodes[] = { ARM::VST3d8Pseudo_UPD,
ARM::VST3d16Pseudo_UPD,
ARM::VST3d32Pseudo_UPD,
ARM::<API key>};
static const uint16_t QOpcodes0[] = { ARM::VST3q8Pseudo_UPD,
ARM::VST3q16Pseudo_UPD,
ARM::VST3q32Pseudo_UPD };
static const uint16_t QOpcodes1[] = { ARM::VST3q8oddPseudo_UPD,
ARM::<API key>,
ARM::<API key> };
SelectVST(N, true, 3, DOpcodes, QOpcodes0, QOpcodes1);
return;
}
case ARMISD::VST4_UPD: {
static const uint16_t DOpcodes[] = { ARM::VST4d8Pseudo_UPD,
ARM::VST4d16Pseudo_UPD,
ARM::VST4d32Pseudo_UPD,
ARM::<API key>};
static const uint16_t QOpcodes0[] = { ARM::VST4q8Pseudo_UPD,
ARM::VST4q16Pseudo_UPD,
ARM::VST4q32Pseudo_UPD };
static const uint16_t QOpcodes1[] = { ARM::VST4q8oddPseudo_UPD,
ARM::<API key>,
ARM::<API key> };
SelectVST(N, true, 4, DOpcodes, QOpcodes0, QOpcodes1);
return;
}
case ARMISD::VST2LN_UPD: {
static const uint16_t DOpcodes[] = { ARM::VST2LNd8Pseudo_UPD,
ARM::VST2LNd16Pseudo_UPD,
ARM::VST2LNd32Pseudo_UPD };
static const uint16_t QOpcodes[] = { ARM::VST2LNq16Pseudo_UPD,
ARM::VST2LNq32Pseudo_UPD };
SelectVLDSTLane(N, false, true, 2, DOpcodes, QOpcodes);
return;
}
case ARMISD::VST3LN_UPD: {
static const uint16_t DOpcodes[] = { ARM::VST3LNd8Pseudo_UPD,
ARM::VST3LNd16Pseudo_UPD,
ARM::VST3LNd32Pseudo_UPD };
static const uint16_t QOpcodes[] = { ARM::VST3LNq16Pseudo_UPD,
ARM::VST3LNq32Pseudo_UPD };
SelectVLDSTLane(N, false, true, 3, DOpcodes, QOpcodes);
return;
}
case ARMISD::VST4LN_UPD: {
static const uint16_t DOpcodes[] = { ARM::VST4LNd8Pseudo_UPD,
ARM::VST4LNd16Pseudo_UPD,
ARM::VST4LNd32Pseudo_UPD };
static const uint16_t QOpcodes[] = { ARM::VST4LNq16Pseudo_UPD,
ARM::VST4LNq32Pseudo_UPD };
SelectVLDSTLane(N, false, true, 4, DOpcodes, QOpcodes);
return;
}
case ISD::INTRINSIC_VOID:
case ISD::INTRINSIC_W_CHAIN: {
unsigned IntNo = cast<ConstantSDNode>(N->getOperand(1))->getZExtValue();
switch (IntNo) {
default:
break;
case Intrinsic::arm_mrrc:
case Intrinsic::arm_mrrc2: {
SDLoc dl(N);
SDValue Chain = N->getOperand(0);
unsigned Opc;
if (Subtarget->isThumb())
Opc = (IntNo == Intrinsic::arm_mrrc ? ARM::t2MRRC : ARM::t2MRRC2);
else
Opc = (IntNo == Intrinsic::arm_mrrc ? ARM::MRRC : ARM::MRRC2);
SmallVector<SDValue, 5> Ops;
Ops.push_back(getI32Imm(cast<ConstantSDNode>(N->getOperand(2))->getZExtValue(), dl)); /* coproc */
Ops.push_back(getI32Imm(cast<ConstantSDNode>(N->getOperand(3))->getZExtValue(), dl)); /* opc */
Ops.push_back(getI32Imm(cast<ConstantSDNode>(N->getOperand(4))->getZExtValue(), dl)); /* CRm */
// The mrrc2 instruction in ARM doesn't allow predicates, the top 4 bits of the encoded
// instruction will always be '1111' but it is possible in assembly language to specify
// AL as a predicate to mrrc2 but it doesn't make any difference to the encoded instruction.
if (Opc != ARM::MRRC2) {
Ops.push_back(getAL(CurDAG, dl));
Ops.push_back(CurDAG->getRegister(0, MVT::i32));
}
Ops.push_back(Chain);
// Writes to two registers.
const EVT RetType[] = {MVT::i32, MVT::i32, MVT::Other};
ReplaceNode(N, CurDAG->getMachineNode(Opc, dl, RetType, Ops));
return;
}
case Intrinsic::arm_ldaexd:
case Intrinsic::arm_ldrexd: {
SDLoc dl(N);
SDValue Chain = N->getOperand(0);
SDValue MemAddr = N->getOperand(2);
bool isThumb = Subtarget->isThumb() && Subtarget->hasV8MBaselineOps();
bool IsAcquire = IntNo == Intrinsic::arm_ldaexd;
unsigned NewOpc = isThumb ? (IsAcquire ? ARM::t2LDAEXD : ARM::t2LDREXD)
: (IsAcquire ? ARM::LDAEXD : ARM::LDREXD);
// arm_ldrexd returns a i64 value in {i32, i32}
std::vector<EVT> ResTys;
if (isThumb) {
ResTys.push_back(MVT::i32);
ResTys.push_back(MVT::i32);
} else
ResTys.push_back(MVT::Untyped);
ResTys.push_back(MVT::Other);
// Place arguments in the right order.
SDValue Ops[] = {MemAddr, getAL(CurDAG, dl),
CurDAG->getRegister(0, MVT::i32), Chain};
SDNode *Ld = CurDAG->getMachineNode(NewOpc, dl, ResTys, Ops);
// Transfer memoperands.
MachineMemOperand *MemOp = cast<MemIntrinsicSDNode>(N)->getMemOperand();
CurDAG->setNodeMemRefs(cast<MachineSDNode>(Ld), {MemOp});
// Remap uses.
SDValue OutChain = isThumb ? SDValue(Ld, 2) : SDValue(Ld, 1);
if (!SDValue(N, 0).use_empty()) {
SDValue Result;
if (isThumb)
Result = SDValue(Ld, 0);
else {
SDValue SubRegIdx =
CurDAG->getTargetConstant(ARM::gsub_0, dl, MVT::i32);
SDNode *ResNode = CurDAG->getMachineNode(TargetOpcode::EXTRACT_SUBREG,
dl, MVT::i32, SDValue(Ld, 0), SubRegIdx);
Result = SDValue(ResNode,0);
}
ReplaceUses(SDValue(N, 0), Result);
}
if (!SDValue(N, 1).use_empty()) {
SDValue Result;
if (isThumb)
Result = SDValue(Ld, 1);
else {
SDValue SubRegIdx =
CurDAG->getTargetConstant(ARM::gsub_1, dl, MVT::i32);
SDNode *ResNode = CurDAG->getMachineNode(TargetOpcode::EXTRACT_SUBREG,
dl, MVT::i32, SDValue(Ld, 0), SubRegIdx);
Result = SDValue(ResNode,0);
}
ReplaceUses(SDValue(N, 1), Result);
}
ReplaceUses(SDValue(N, 2), OutChain);
CurDAG->RemoveDeadNode(N);
return;
}
case Intrinsic::arm_stlexd:
case Intrinsic::arm_strexd: {
SDLoc dl(N);
SDValue Chain = N->getOperand(0);
SDValue Val0 = N->getOperand(2);
SDValue Val1 = N->getOperand(3);
SDValue MemAddr = N->getOperand(4);
// Store exclusive double return a i32 value which is the return status
// of the issued store.
const EVT ResTys[] = {MVT::i32, MVT::Other};
bool isThumb = Subtarget->isThumb() && Subtarget->hasThumb2();
// Place arguments in the right order.
SmallVector<SDValue, 7> Ops;
if (isThumb) {
Ops.push_back(Val0);
Ops.push_back(Val1);
} else
// arm_strexd uses GPRPair.
Ops.push_back(SDValue(createGPRPairNode(MVT::Untyped, Val0, Val1), 0));
Ops.push_back(MemAddr);
Ops.push_back(getAL(CurDAG, dl));
Ops.push_back(CurDAG->getRegister(0, MVT::i32));
Ops.push_back(Chain);
bool IsRelease = IntNo == Intrinsic::arm_stlexd;
unsigned NewOpc = isThumb ? (IsRelease ? ARM::t2STLEXD : ARM::t2STREXD)
: (IsRelease ? ARM::STLEXD : ARM::STREXD);
SDNode *St = CurDAG->getMachineNode(NewOpc, dl, ResTys, Ops);
// Transfer memoperands.
MachineMemOperand *MemOp = cast<MemIntrinsicSDNode>(N)->getMemOperand();
CurDAG->setNodeMemRefs(cast<MachineSDNode>(St), {MemOp});
ReplaceNode(N, St);
return;
}
case Intrinsic::arm_neon_vld1: {
static const uint16_t DOpcodes[] = { ARM::VLD1d8, ARM::VLD1d16,
ARM::VLD1d32, ARM::VLD1d64 };
static const uint16_t QOpcodes[] = { ARM::VLD1q8, ARM::VLD1q16,
ARM::VLD1q32, ARM::VLD1q64};
SelectVLD(N, false, 1, DOpcodes, QOpcodes, nullptr);
return;
}
case Intrinsic::arm_neon_vld1x2: {
static const uint16_t DOpcodes[] = { ARM::VLD1q8, ARM::VLD1q16,
ARM::VLD1q32, ARM::VLD1q64 };
static const uint16_t QOpcodes[] = { ARM::VLD1d8QPseudo,
ARM::VLD1d16QPseudo,
ARM::VLD1d32QPseudo,
ARM::VLD1d64QPseudo };
SelectVLD(N, false, 2, DOpcodes, QOpcodes, nullptr);
return;
}
case Intrinsic::arm_neon_vld1x3: {
static const uint16_t DOpcodes[] = { ARM::VLD1d8TPseudo,
ARM::VLD1d16TPseudo,
ARM::VLD1d32TPseudo,
ARM::VLD1d64TPseudo };
static const uint16_t QOpcodes0[] = { ARM::<API key>,
ARM::<API key>,
ARM::<API key>,
ARM::<API key> };
static const uint16_t QOpcodes1[] = { ARM::VLD1q8HighTPseudo,
ARM::VLD1q16HighTPseudo,
ARM::VLD1q32HighTPseudo,
ARM::VLD1q64HighTPseudo };
SelectVLD(N, false, 3, DOpcodes, QOpcodes0, QOpcodes1);
return;
}
case Intrinsic::arm_neon_vld1x4: {
static const uint16_t DOpcodes[] = { ARM::VLD1d8QPseudo,
ARM::VLD1d16QPseudo,
ARM::VLD1d32QPseudo,
ARM::VLD1d64QPseudo };
static const uint16_t QOpcodes0[] = { ARM::<API key>,
ARM::<API key>,
ARM::<API key>,
ARM::<API key> };
static const uint16_t QOpcodes1[] = { ARM::VLD1q8HighQPseudo,
ARM::VLD1q16HighQPseudo,
ARM::VLD1q32HighQPseudo,
ARM::VLD1q64HighQPseudo };
SelectVLD(N, false, 4, DOpcodes, QOpcodes0, QOpcodes1);
return;
}
case Intrinsic::arm_neon_vld2: {
static const uint16_t DOpcodes[] = { ARM::VLD2d8, ARM::VLD2d16,
ARM::VLD2d32, ARM::VLD1q64 };
static const uint16_t QOpcodes[] = { ARM::VLD2q8Pseudo, ARM::VLD2q16Pseudo,
ARM::VLD2q32Pseudo };
SelectVLD(N, false, 2, DOpcodes, QOpcodes, nullptr);
return;
}
case Intrinsic::arm_neon_vld3: {
static const uint16_t DOpcodes[] = { ARM::VLD3d8Pseudo,
ARM::VLD3d16Pseudo,
ARM::VLD3d32Pseudo,
ARM::VLD1d64TPseudo };
static const uint16_t QOpcodes0[] = { ARM::VLD3q8Pseudo_UPD,
ARM::VLD3q16Pseudo_UPD,
ARM::VLD3q32Pseudo_UPD };
static const uint16_t QOpcodes1[] = { ARM::VLD3q8oddPseudo,
ARM::VLD3q16oddPseudo,
ARM::VLD3q32oddPseudo };
SelectVLD(N, false, 3, DOpcodes, QOpcodes0, QOpcodes1);
return;
}
case Intrinsic::arm_neon_vld4: {
static const uint16_t DOpcodes[] = { ARM::VLD4d8Pseudo,
ARM::VLD4d16Pseudo,
ARM::VLD4d32Pseudo,
ARM::VLD1d64QPseudo };
static const uint16_t QOpcodes0[] = { ARM::VLD4q8Pseudo_UPD,
ARM::VLD4q16Pseudo_UPD,
ARM::VLD4q32Pseudo_UPD };
static const uint16_t QOpcodes1[] = { ARM::VLD4q8oddPseudo,
ARM::VLD4q16oddPseudo,
ARM::VLD4q32oddPseudo };
SelectVLD(N, false, 4, DOpcodes, QOpcodes0, QOpcodes1);
return;
}
case Intrinsic::arm_neon_vld2dup: {
static const uint16_t DOpcodes[] = { ARM::VLD2DUPd8, ARM::VLD2DUPd16,
ARM::VLD2DUPd32, ARM::VLD1q64 };
static const uint16_t QOpcodes0[] = { ARM::VLD2DUPq8EvenPseudo,
ARM::<API key>,
ARM::<API key> };
static const uint16_t QOpcodes1[] = { ARM::VLD2DUPq8OddPseudo,
ARM::VLD2DUPq16OddPseudo,
ARM::VLD2DUPq32OddPseudo };
SelectVLDDup(N, /* IsIntrinsic= */ true, false, 2,
DOpcodes, QOpcodes0, QOpcodes1);
return;
}
case Intrinsic::arm_neon_vld3dup: {
static const uint16_t DOpcodes[] = { ARM::VLD3DUPd8Pseudo,
ARM::VLD3DUPd16Pseudo,
ARM::VLD3DUPd32Pseudo,
ARM::VLD1d64TPseudo };
static const uint16_t QOpcodes0[] = { ARM::VLD3DUPq8EvenPseudo,
ARM::<API key>,
ARM::<API key> };
static const uint16_t QOpcodes1[] = { ARM::VLD3DUPq8OddPseudo,
ARM::VLD3DUPq16OddPseudo,
ARM::VLD3DUPq32OddPseudo };
SelectVLDDup(N, /* IsIntrinsic= */ true, false, 3,
DOpcodes, QOpcodes0, QOpcodes1);
return;
}
case Intrinsic::arm_neon_vld4dup: {
static const uint16_t DOpcodes[] = { ARM::VLD4DUPd8Pseudo,
ARM::VLD4DUPd16Pseudo,
ARM::VLD4DUPd32Pseudo,
ARM::VLD1d64QPseudo };
static const uint16_t QOpcodes0[] = { ARM::VLD4DUPq8EvenPseudo,
ARM::<API key>,
ARM::<API key> };
static const uint16_t QOpcodes1[] = { ARM::VLD4DUPq8OddPseudo,
ARM::VLD4DUPq16OddPseudo,
ARM::VLD4DUPq32OddPseudo };
SelectVLDDup(N, /* IsIntrinsic= */ true, false, 4,
DOpcodes, QOpcodes0, QOpcodes1);
return;
}
case Intrinsic::arm_neon_vld2lane: {
static const uint16_t DOpcodes[] = { ARM::VLD2LNd8Pseudo,
ARM::VLD2LNd16Pseudo,
ARM::VLD2LNd32Pseudo };
static const uint16_t QOpcodes[] = { ARM::VLD2LNq16Pseudo,
ARM::VLD2LNq32Pseudo };
SelectVLDSTLane(N, true, false, 2, DOpcodes, QOpcodes);
return;
}
case Intrinsic::arm_neon_vld3lane: {
static const uint16_t DOpcodes[] = { ARM::VLD3LNd8Pseudo,
ARM::VLD3LNd16Pseudo,
ARM::VLD3LNd32Pseudo };
static const uint16_t QOpcodes[] = { ARM::VLD3LNq16Pseudo,
ARM::VLD3LNq32Pseudo };
SelectVLDSTLane(N, true, false, 3, DOpcodes, QOpcodes);
return;
}
case Intrinsic::arm_neon_vld4lane: {
static const uint16_t DOpcodes[] = { ARM::VLD4LNd8Pseudo,
ARM::VLD4LNd16Pseudo,
ARM::VLD4LNd32Pseudo };
static const uint16_t QOpcodes[] = { ARM::VLD4LNq16Pseudo,
ARM::VLD4LNq32Pseudo };
SelectVLDSTLane(N, true, false, 4, DOpcodes, QOpcodes);
return;
}
case Intrinsic::arm_neon_vst1: {
static const uint16_t DOpcodes[] = { ARM::VST1d8, ARM::VST1d16,
ARM::VST1d32, ARM::VST1d64 };
static const uint16_t QOpcodes[] = { ARM::VST1q8, ARM::VST1q16,
ARM::VST1q32, ARM::VST1q64 };
SelectVST(N, false, 1, DOpcodes, QOpcodes, nullptr);
return;
}
case Intrinsic::arm_neon_vst1x2: {
static const uint16_t DOpcodes[] = { ARM::VST1q8, ARM::VST1q16,
ARM::VST1q32, ARM::VST1q64 };
static const uint16_t QOpcodes[] = { ARM::VST1d8QPseudo,
ARM::VST1d16QPseudo,
ARM::VST1d32QPseudo,
ARM::VST1d64QPseudo };
SelectVST(N, false, 2, DOpcodes, QOpcodes, nullptr);
return;
}
case Intrinsic::arm_neon_vst1x3: {
static const uint16_t DOpcodes[] = { ARM::VST1d8TPseudo,
ARM::VST1d16TPseudo,
ARM::VST1d32TPseudo,
ARM::VST1d64TPseudo };
static const uint16_t QOpcodes0[] = { ARM::<API key>,
ARM::<API key>,
ARM::<API key>,
ARM::<API key> };
static const uint16_t QOpcodes1[] = { ARM::VST1q8HighTPseudo,
ARM::VST1q16HighTPseudo,
ARM::VST1q32HighTPseudo,
ARM::VST1q64HighTPseudo };
SelectVST(N, false, 3, DOpcodes, QOpcodes0, QOpcodes1);
return;
}
case Intrinsic::arm_neon_vst1x4: {
static const uint16_t DOpcodes[] = { ARM::VST1d8QPseudo,
ARM::VST1d16QPseudo,
ARM::VST1d32QPseudo,
ARM::VST1d64QPseudo };
static const uint16_t QOpcodes0[] = { ARM::<API key>,
ARM::<API key>,
ARM::<API key>,
ARM::<API key> };
static const uint16_t QOpcodes1[] = { ARM::VST1q8HighQPseudo,
ARM::VST1q16HighQPseudo,
ARM::VST1q32HighQPseudo,
ARM::VST1q64HighQPseudo };
SelectVST(N, false, 4, DOpcodes, QOpcodes0, QOpcodes1);
return;
}
case Intrinsic::arm_neon_vst2: {
static const uint16_t DOpcodes[] = { ARM::VST2d8, ARM::VST2d16,
ARM::VST2d32, ARM::VST1q64 };
static const uint16_t QOpcodes[] = { ARM::VST2q8Pseudo, ARM::VST2q16Pseudo,
ARM::VST2q32Pseudo };
SelectVST(N, false, 2, DOpcodes, QOpcodes, nullptr);
return;
}
case Intrinsic::arm_neon_vst3: {
static const uint16_t DOpcodes[] = { ARM::VST3d8Pseudo,
ARM::VST3d16Pseudo,
ARM::VST3d32Pseudo,
ARM::VST1d64TPseudo };
static const uint16_t QOpcodes0[] = { ARM::VST3q8Pseudo_UPD,
ARM::VST3q16Pseudo_UPD,
ARM::VST3q32Pseudo_UPD };
static const uint16_t QOpcodes1[] = { ARM::VST3q8oddPseudo,
ARM::VST3q16oddPseudo,
ARM::VST3q32oddPseudo };
SelectVST(N, false, 3, DOpcodes, QOpcodes0, QOpcodes1);
return;
}
case Intrinsic::arm_neon_vst4: {
static const uint16_t DOpcodes[] = { ARM::VST4d8Pseudo,
ARM::VST4d16Pseudo,
ARM::VST4d32Pseudo,
ARM::VST1d64QPseudo };
static const uint16_t QOpcodes0[] = { ARM::VST4q8Pseudo_UPD,
ARM::VST4q16Pseudo_UPD,
ARM::VST4q32Pseudo_UPD };
static const uint16_t QOpcodes1[] = { ARM::VST4q8oddPseudo,
ARM::VST4q16oddPseudo,
ARM::VST4q32oddPseudo };
SelectVST(N, false, 4, DOpcodes, QOpcodes0, QOpcodes1);
return;
}
case Intrinsic::arm_neon_vst2lane: {
static const uint16_t DOpcodes[] = { ARM::VST2LNd8Pseudo,
ARM::VST2LNd16Pseudo,
ARM::VST2LNd32Pseudo };
static const uint16_t QOpcodes[] = { ARM::VST2LNq16Pseudo,
ARM::VST2LNq32Pseudo };
SelectVLDSTLane(N, false, false, 2, DOpcodes, QOpcodes);
return;
}
case Intrinsic::arm_neon_vst3lane: {
static const uint16_t DOpcodes[] = { ARM::VST3LNd8Pseudo,
ARM::VST3LNd16Pseudo,
ARM::VST3LNd32Pseudo };
static const uint16_t QOpcodes[] = { ARM::VST3LNq16Pseudo,
ARM::VST3LNq32Pseudo };
SelectVLDSTLane(N, false, false, 3, DOpcodes, QOpcodes);
return;
}
case Intrinsic::arm_neon_vst4lane: {
static const uint16_t DOpcodes[] = { ARM::VST4LNd8Pseudo,
ARM::VST4LNd16Pseudo,
ARM::VST4LNd32Pseudo };
static const uint16_t QOpcodes[] = { ARM::VST4LNq16Pseudo,
ARM::VST4LNq32Pseudo };
SelectVLDSTLane(N, false, false, 4, DOpcodes, QOpcodes);
return;
}
}
break;
}
case ISD::ATOMIC_CMP_SWAP:
SelectCMP_SWAP(N);
return;
}
SelectCode(N);
}
// Inspect a register string of the form
// cp<coprocessor>:<opc1>:c<CRn>:c<CRm>:<opc2> (32bit) or
// cp<coprocessor>:<opc1>:c<CRm> (64bit) inspect the fields of the string
// and obtain the integer operands from them, adding these operands to the
// provided vector.
static void <API key>(StringRef RegString,
SelectionDAG *CurDAG,
const SDLoc &DL,
std::vector<SDValue> &Ops) {
SmallVector<StringRef, 5> Fields;
RegString.split(Fields, ':');
if (Fields.size() > 1) {
bool AllIntFields = true;
for (StringRef Field : Fields) {
// Need to trim out leading 'cp' characters and get the integer field.
unsigned IntField;
AllIntFields &= !Field.trim("CPcp").getAsInteger(10, IntField);
Ops.push_back(CurDAG->getTargetConstant(IntField, DL, MVT::i32));
}
assert(AllIntFields &&
"Unexpected non-integer value in special register string.");
}
}
// Maps a Banked Register string to its mask value. The mask value returned is
// for use in the MRSbanked / MSRbanked instruction nodes as the Banked Register
// mask operand, which expresses which register is to be used, e.g. r8, and in
// which mode it is to be used, e.g. usr. Returns -1 to signify that the string
// was invalid.
static inline int <API key>(StringRef RegString) {
auto TheReg = ARMBankedReg::<API key>(RegString.lower());
if (!TheReg)
return -1;
return TheReg->Encoding;
}
// The flags here are common to those allowed for apsr in the A class cores and
// those allowed for the special registers in the M class cores. Returns a
// value representing which flags were present, -1 if invalid.
static inline int getMClassFlagsMask(StringRef Flags) {
return StringSwitch<int>(Flags)
.Case("", 0x2) // no flags means nzcvq for psr registers, and 0x2 is
// correct when flags are not permitted
.Case("g", 0x1)
.Case("nzcvq", 0x2)
.Case("nzcvqg", 0x3)
.Default(-1);
}
// Maps MClass special registers string to its value for use in the
// t2MRS_M/t2MSR_M instruction nodes as the SYSm value operand.
// Returns -1 to signify that the string was invalid.
static int <API key>(StringRef Reg, const ARMSubtarget *Subtarget) {
auto TheReg = ARMSysReg::<API key>(Reg);
const FeatureBitset &FeatureBits = Subtarget->getFeatureBits();
if (!TheReg || !TheReg->hasRequiredFeatures(FeatureBits))
return -1;
return (int)(TheReg->Encoding & 0xFFF); // SYSm value
}
static int <API key>(StringRef Reg, StringRef Flags) {
// The mask operand contains the special register (R Bit) in bit 4, whether
// the register is spsr (R bit is 1) or one of cpsr/apsr (R bit is 0), and
// bits 3-0 contains the fields to be accessed in the special register, set by
// the flags provided with the register.
int Mask = 0;
if (Reg == "apsr") {
// The flags permitted for apsr are the same flags that are allowed in
// M class registers. We get the flag value and then shift the flags into
// the correct place to combine with the mask.
Mask = getMClassFlagsMask(Flags);
if (Mask == -1)
return -1;
return Mask << 2;
}
if (Reg != "cpsr" && Reg != "spsr") {
return -1;
}
// This is the same as if the flags were "fc"
if (Flags.empty() || Flags == "all")
return Mask | 0x9;
// Inspect the supplied flags string and set the bits in the mask for
// the relevant and valid flags allowed for cpsr and spsr.
for (char Flag : Flags) {
int FlagVal;
switch (Flag) {
case 'c':
FlagVal = 0x1;
break;
case 'x':
FlagVal = 0x2;
break;
case 's':
FlagVal = 0x4;
break;
case 'f':
FlagVal = 0x8;
break;
default:
FlagVal = 0;
}
// This avoids allowing strings where the same flag bit appears twice.
if (!FlagVal || (Mask & FlagVal))
return -1;
Mask |= FlagVal;
}
// If the register is spsr then we need to set the R bit.
if (Reg == "spsr")
Mask |= 0x10;
return Mask;
}
// Lower the read_register intrinsic to ARM specific DAG nodes
// using the supplied metadata string to select the instruction node to use
// and the registers/masks to construct as operands for the node.
bool ARMDAGToDAGISel::tryReadRegister(SDNode *N){
const MDNodeSDNode *MD = dyn_cast<MDNodeSDNode>(N->getOperand(1));
const MDString *RegString = dyn_cast<MDString>(MD->getMD()->getOperand(0));
bool IsThumb2 = Subtarget->isThumb2();
SDLoc DL(N);
std::vector<SDValue> Ops;
<API key>(RegString->getString(), CurDAG, DL, Ops);
if (!Ops.empty()) {
// If the special register string was constructed of fields (as defined
// in the ACLE) then need to lower to MRC node (32 bit) or
// MRRC node(64 bit), we can make the distinction based on the number of
// operands we have.
unsigned Opcode;
SmallVector<EVT, 3> ResTypes;
if (Ops.size() == 5){
Opcode = IsThumb2 ? ARM::t2MRC : ARM::MRC;
ResTypes.append({ MVT::i32, MVT::Other });
} else {
assert(Ops.size() == 3 &&
"Invalid number of fields in special register string.");
Opcode = IsThumb2 ? ARM::t2MRRC : ARM::MRRC;
ResTypes.append({ MVT::i32, MVT::i32, MVT::Other });
}
Ops.push_back(getAL(CurDAG, DL));
Ops.push_back(CurDAG->getRegister(0, MVT::i32));
Ops.push_back(N->getOperand(0));
ReplaceNode(N, CurDAG->getMachineNode(Opcode, DL, ResTypes, Ops));
return true;
}
std::string SpecialReg = RegString->getString().lower();
int BankedReg = <API key>(SpecialReg);
if (BankedReg != -1) {
Ops = { CurDAG->getTargetConstant(BankedReg, DL, MVT::i32),
getAL(CurDAG, DL), CurDAG->getRegister(0, MVT::i32),
N->getOperand(0) };
ReplaceNode(
N, CurDAG->getMachineNode(IsThumb2 ? ARM::t2MRSbanked : ARM::MRSbanked,
DL, MVT::i32, MVT::Other, Ops));
return true;
}
// The VFP registers are read by creating SelectionDAG nodes with opcodes
// corresponding to the register that is being read from. So we switch on the
// string to find which opcode we need to use.
unsigned Opcode = StringSwitch<unsigned>(SpecialReg)
.Case("fpscr", ARM::VMRS)
.Case("fpexc", ARM::VMRS_FPEXC)
.Case("fpsid", ARM::VMRS_FPSID)
.Case("mvfr0", ARM::VMRS_MVFR0)
.Case("mvfr1", ARM::VMRS_MVFR1)
.Case("mvfr2", ARM::VMRS_MVFR2)
.Case("fpinst", ARM::VMRS_FPINST)
.Case("fpinst2", ARM::VMRS_FPINST2)
.Default(0);
// If an opcode was found then we can lower the read to a VFP instruction.
if (Opcode) {
if (!Subtarget->hasVFP2Base())
return false;
if (Opcode == ARM::VMRS_MVFR2 && !Subtarget->hasFPARMv8Base())
return false;
Ops = { getAL(CurDAG, DL), CurDAG->getRegister(0, MVT::i32),
N->getOperand(0) };
ReplaceNode(N,
CurDAG->getMachineNode(Opcode, DL, MVT::i32, MVT::Other, Ops));
return true;
}
// If the target is M Class then need to validate that the register string
// is an acceptable value, so check that a mask can be constructed from the
// string.
if (Subtarget->isMClass()) {
int SYSmValue = <API key>(SpecialReg, Subtarget);
if (SYSmValue == -1)
return false;
SDValue Ops[] = { CurDAG->getTargetConstant(SYSmValue, DL, MVT::i32),
getAL(CurDAG, DL), CurDAG->getRegister(0, MVT::i32),
N->getOperand(0) };
ReplaceNode(
N, CurDAG->getMachineNode(ARM::t2MRS_M, DL, MVT::i32, MVT::Other, Ops));
return true;
}
// Here we know the target is not M Class so we need to check if it is one
// of the remaining possible values which are apsr, cpsr or spsr.
if (SpecialReg == "apsr" || SpecialReg == "cpsr") {
Ops = { getAL(CurDAG, DL), CurDAG->getRegister(0, MVT::i32),
N->getOperand(0) };
ReplaceNode(N, CurDAG->getMachineNode(IsThumb2 ? ARM::t2MRS_AR : ARM::MRS,
DL, MVT::i32, MVT::Other, Ops));
return true;
}
if (SpecialReg == "spsr") {
Ops = { getAL(CurDAG, DL), CurDAG->getRegister(0, MVT::i32),
N->getOperand(0) };
ReplaceNode(
N, CurDAG->getMachineNode(IsThumb2 ? ARM::t2MRSsys_AR : ARM::MRSsys, DL,
MVT::i32, MVT::Other, Ops));
return true;
}
return false;
}
// Lower the write_register intrinsic to ARM specific DAG nodes
// using the supplied metadata string to select the instruction node to use
// and the registers/masks to use in the nodes
bool ARMDAGToDAGISel::tryWriteRegister(SDNode *N){
const MDNodeSDNode *MD = dyn_cast<MDNodeSDNode>(N->getOperand(1));
const MDString *RegString = dyn_cast<MDString>(MD->getMD()->getOperand(0));
bool IsThumb2 = Subtarget->isThumb2();
SDLoc DL(N);
std::vector<SDValue> Ops;
<API key>(RegString->getString(), CurDAG, DL, Ops);
if (!Ops.empty()) {
// If the special register string was constructed of fields (as defined
// in the ACLE) then need to lower to MCR node (32 bit) or
// MCRR node(64 bit), we can make the distinction based on the number of
// operands we have.
unsigned Opcode;
if (Ops.size() == 5) {
Opcode = IsThumb2 ? ARM::t2MCR : ARM::MCR;
Ops.insert(Ops.begin()+2, N->getOperand(2));
} else {
assert(Ops.size() == 3 &&
"Invalid number of fields in special register string.");
Opcode = IsThumb2 ? ARM::t2MCRR : ARM::MCRR;
SDValue WriteValue[] = { N->getOperand(2), N->getOperand(3) };
Ops.insert(Ops.begin()+2, WriteValue, WriteValue+2);
}
Ops.push_back(getAL(CurDAG, DL));
Ops.push_back(CurDAG->getRegister(0, MVT::i32));
Ops.push_back(N->getOperand(0));
ReplaceNode(N, CurDAG->getMachineNode(Opcode, DL, MVT::Other, Ops));
return true;
}
std::string SpecialReg = RegString->getString().lower();
int BankedReg = <API key>(SpecialReg);
if (BankedReg != -1) {
Ops = { CurDAG->getTargetConstant(BankedReg, DL, MVT::i32), N->getOperand(2),
getAL(CurDAG, DL), CurDAG->getRegister(0, MVT::i32),
N->getOperand(0) };
ReplaceNode(
N, CurDAG->getMachineNode(IsThumb2 ? ARM::t2MSRbanked : ARM::MSRbanked,
DL, MVT::Other, Ops));
return true;
}
// The VFP registers are written to by creating SelectionDAG nodes with
// opcodes corresponding to the register that is being written. So we switch
// on the string to find which opcode we need to use.
unsigned Opcode = StringSwitch<unsigned>(SpecialReg)
.Case("fpscr", ARM::VMSR)
.Case("fpexc", ARM::VMSR_FPEXC)
.Case("fpsid", ARM::VMSR_FPSID)
.Case("fpinst", ARM::VMSR_FPINST)
.Case("fpinst2", ARM::VMSR_FPINST2)
.Default(0);
if (Opcode) {
if (!Subtarget->hasVFP2Base())
return false;
Ops = { N->getOperand(2), getAL(CurDAG, DL),
CurDAG->getRegister(0, MVT::i32), N->getOperand(0) };
ReplaceNode(N, CurDAG->getMachineNode(Opcode, DL, MVT::Other, Ops));
return true;
}
std::pair<StringRef, StringRef> Fields;
Fields = StringRef(SpecialReg).rsplit('_');
std::string Reg = Fields.first.str();
StringRef Flags = Fields.second;
// If the target was M Class then need to validate the special register value
// and retrieve the mask for use in the instruction node.
if (Subtarget->isMClass()) {
int SYSmValue = <API key>(SpecialReg, Subtarget);
if (SYSmValue == -1)
return false;
SDValue Ops[] = { CurDAG->getTargetConstant(SYSmValue, DL, MVT::i32),
N->getOperand(2), getAL(CurDAG, DL),
CurDAG->getRegister(0, MVT::i32), N->getOperand(0) };
ReplaceNode(N, CurDAG->getMachineNode(ARM::t2MSR_M, DL, MVT::Other, Ops));
return true;
}
// We then check to see if a valid mask can be constructed for one of the
// register string values permitted for the A and R class cores. These values
// are apsr, spsr and cpsr; these are also valid on older cores.
int Mask = <API key>(Reg, Flags);
if (Mask != -1) {
Ops = { CurDAG->getTargetConstant(Mask, DL, MVT::i32), N->getOperand(2),
getAL(CurDAG, DL), CurDAG->getRegister(0, MVT::i32),
N->getOperand(0) };
ReplaceNode(N, CurDAG->getMachineNode(IsThumb2 ? ARM::t2MSR_AR : ARM::MSR,
DL, MVT::Other, Ops));
return true;
}
return false;
}
bool ARMDAGToDAGISel::tryInlineAsm(SDNode *N){
std::vector<SDValue> AsmNodeOperands;
unsigned Flag, Kind;
bool Changed = false;
unsigned NumOps = N->getNumOperands();
// Normally, i64 data is bounded to two arbitrary GRPs for "%r" constraint.
// However, some instrstions (e.g. ldrexd/strexd in ARM mode) require
// (even/even+1) GPRs and use %n and %Hn to refer to the individual regs
// respectively. Since there is no constraint to explicitly specify a
// reg pair, we use GPRPair reg class for "%r" for 64-bit data. For Thumb,
// the 64-bit data may be referred by H, Q, R modifiers, so we still pack
// them into a GPRPair.
SDLoc dl(N);
SDValue Glue = N->getGluedNode() ? N->getOperand(NumOps-1)
: SDValue(nullptr,0);
SmallVector<bool, 8> OpChanged;
// Glue node will be appended late.
for(unsigned i = 0, e = N->getGluedNode() ? NumOps - 1 : NumOps; i < e; ++i) {
SDValue op = N->getOperand(i);
AsmNodeOperands.push_back(op);
if (i < InlineAsm::Op_FirstOperand)
continue;
if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(N->getOperand(i))) {
Flag = C->getZExtValue();
Kind = InlineAsm::getKind(Flag);
}
else
continue;
// Immediate operands to inline asm in the SelectionDAG are modeled with
// two operands. The first is a constant of value InlineAsm::Kind_Imm, and
// the second is a constant with the value of the immediate. If we get here
// and we have a Kind_Imm, skip the next operand, and continue.
if (Kind == InlineAsm::Kind_Imm) {
SDValue op = N->getOperand(++i);
AsmNodeOperands.push_back(op);
continue;
}
unsigned NumRegs = InlineAsm::<API key>(Flag);
if (NumRegs)
OpChanged.push_back(false);
unsigned DefIdx = 0;
bool IsTiedToChangedOp = false;
// If it's a use that is tied with a previous def, it has no
// reg class constraint.
if (Changed && InlineAsm::<API key>(Flag, DefIdx))
IsTiedToChangedOp = OpChanged[DefIdx];
// Memory operands to inline asm in the SelectionDAG are modeled with two
// operands: a constant of value InlineAsm::Kind_Mem followed by the input
// operand. If we get here and we have a Kind_Mem, skip the next operand (so
// it doesn't get misinterpreted), and continue. We do this here because
// it's important to update the OpChanged array correctly before moving on.
if (Kind == InlineAsm::Kind_Mem) {
SDValue op = N->getOperand(++i);
AsmNodeOperands.push_back(op);
continue;
}
if (Kind != InlineAsm::Kind_RegUse && Kind != InlineAsm::Kind_RegDef
&& Kind != InlineAsm::<API key>)
continue;
unsigned RC;
bool HasRC = InlineAsm::<API key>(Flag, RC);
if ((!IsTiedToChangedOp && (!HasRC || RC != ARM::GPRRegClassID))
|| NumRegs != 2)
continue;
assert((i+2 < NumOps) && "Invalid number of operands in inline asm");
SDValue V0 = N->getOperand(i+1);
SDValue V1 = N->getOperand(i+2);
unsigned Reg0 = cast<RegisterSDNode>(V0)->getReg();
unsigned Reg1 = cast<RegisterSDNode>(V1)->getReg();
SDValue PairedReg;
MachineRegisterInfo &MRI = MF->getRegInfo();
if (Kind == InlineAsm::Kind_RegDef ||
Kind == InlineAsm::<API key>) {
// Replace the two GPRs with 1 GPRPair and copy values from GPRPair to
// the original GPRs.
unsigned GPVR = MRI.<API key>(&ARM::GPRPairRegClass);
PairedReg = CurDAG->getRegister(GPVR, MVT::Untyped);
SDValue Chain = SDValue(N,0);
SDNode *GU = N->getGluedUser();
SDValue RegCopy = CurDAG->getCopyFromReg(Chain, dl, GPVR, MVT::Untyped,
Chain.getValue(1));
// Extract values from a GPRPair reg and copy to the original GPR reg.
SDValue Sub0 = CurDAG-><API key>(ARM::gsub_0, dl, MVT::i32,
RegCopy);
SDValue Sub1 = CurDAG-><API key>(ARM::gsub_1, dl, MVT::i32,
RegCopy);
SDValue T0 = CurDAG->getCopyToReg(Sub0, dl, Reg0, Sub0,
RegCopy.getValue(1));
SDValue T1 = CurDAG->getCopyToReg(Sub1, dl, Reg1, Sub1, T0.getValue(1));
// Update the original glue user.
std::vector<SDValue> Ops(GU->op_begin(), GU->op_end()-1);
Ops.push_back(T1.getValue(1));
CurDAG->UpdateNodeOperands(GU, Ops);
}
else {
// For Kind == InlineAsm::Kind_RegUse, we first copy two GPRs into a
// GPRPair and then pass the GPRPair to the inline asm.
SDValue Chain = AsmNodeOperands[InlineAsm::Op_InputChain];
// As REG_SEQ doesn't take RegisterSDNode, we copy them first.
SDValue T0 = CurDAG->getCopyFromReg(Chain, dl, Reg0, MVT::i32,
Chain.getValue(1));
SDValue T1 = CurDAG->getCopyFromReg(Chain, dl, Reg1, MVT::i32,
T0.getValue(1));
SDValue Pair = SDValue(createGPRPairNode(MVT::Untyped, T0, T1), 0);
// Copy REG_SEQ into a GPRPair-typed VR and replace the original two
// i32 VRs of inline asm with it.
unsigned GPVR = MRI.<API key>(&ARM::GPRPairRegClass);
PairedReg = CurDAG->getRegister(GPVR, MVT::Untyped);
Chain = CurDAG->getCopyToReg(T1, dl, GPVR, Pair, T1.getValue(1));
AsmNodeOperands[InlineAsm::Op_InputChain] = Chain;
Glue = Chain.getValue(1);
}
Changed = true;
if(PairedReg.getNode()) {
OpChanged[OpChanged.size() -1 ] = true;
Flag = InlineAsm::getFlagWord(Kind, 1 /* RegNum*/);
if (IsTiedToChangedOp)
Flag = InlineAsm::<API key>(Flag, DefIdx);
else
Flag = InlineAsm::<API key>(Flag, ARM::GPRPairRegClassID);
// Replace the current flag.
AsmNodeOperands[AsmNodeOperands.size() -1] = CurDAG->getTargetConstant(
Flag, dl, MVT::i32);
// Add the new register node and skip the original two GPRs.
AsmNodeOperands.push_back(PairedReg);
// Skip the next two GPRs.
i += 2;
}
}
if (Glue.getNode())
AsmNodeOperands.push_back(Glue);
if (!Changed)
return false;
SDValue New = CurDAG->getNode(N->getOpcode(), SDLoc(N),
CurDAG->getVTList(MVT::Other, MVT::Glue), AsmNodeOperands);
New->setNodeId(-1);
ReplaceNode(N, New.getNode());
return true;
}
bool ARMDAGToDAGISel::
<API key>(const SDValue &Op, unsigned ConstraintID,
std::vector<SDValue> &OutOps) {
switch(ConstraintID) {
default:
llvm_unreachable("Unexpected asm memory constraint");
case InlineAsm::Constraint_i:
// FIXME: It seems strange that 'i' is needed here since it's supposed to
// be an immediate and not a memory constraint.
LLVM_FALLTHROUGH;
case InlineAsm::Constraint_m:
case InlineAsm::Constraint_o:
case InlineAsm::Constraint_Q:
case InlineAsm::Constraint_Um:
case InlineAsm::Constraint_Un:
case InlineAsm::Constraint_Uq:
case InlineAsm::Constraint_Us:
case InlineAsm::Constraint_Ut:
case InlineAsm::Constraint_Uv:
case InlineAsm::Constraint_Uy:
// Require the address to be in a register. That is safe for all ARM
// variants and it is hard to do anything much smarter without knowing
// how the operand is used.
OutOps.push_back(Op);
return false;
}
return true;
}
createARMISelDag - This pass converts a legalized DAG into a
ARM-specific DAG, ready for instruction scheduling.
FunctionPass *llvm::createARMISelDag(<API key> &TM,
CodeGenOpt::Level OptLevel) {
return new ARMDAGToDAGISel(TM, OptLevel);
}
|
package com.huawei.esdk.sms.north.http.common;
import java.io.<API key>;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.<API key>;
import javax.xml.parsers.<API key>;
import org.apache.log4j.Logger;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import com.huawei.esdk.platform.common.utils.ESDKIOUtils;
import com.huawei.esdk.platform.common.utils.help.<API key>;
import com.huawei.esdk.sms.north.http.bean.PlaceHolderBean;
public abstract class <API key> implements IXMLProcessor
{
private static Logger LOGGER = Logger.getLogger(<API key>.class);
@Override
public List<PlaceHolderBean> <API key>(String fileName)
throws <API key>, SAXException, IOException
{
String xmlContent = ESDKIOUtils.<API key>(fileName);
return parseXML(xmlContent);
}
@Override
public List<PlaceHolderBean> processXML(String xmlContent)
throws <API key>, SAXException, IOException
{
return parseXML(xmlContent);
}
protected List<PlaceHolderBean> parseXML(String xmlAsString)
throws <API key>, SAXException, IOException
{
<API key> dbFactory = <API key>.newSecurityInstance();
DocumentBuilder dBuilder = dbFactory.newDocumentBuilder();
Document doc = dBuilder.parse(new InputSource(new <API key>(xmlAsString.getBytes("utf-8"))));
doc.getDocumentElement().normalize();
Element rootElement = doc.getDocumentElement();
List<PlaceHolderBean> result = new ArrayList<PlaceHolderBean>();
return parseNode(rootElement, result);
}
protected List<PlaceHolderBean> parseNode(Node nNode, List<PlaceHolderBean> placerHolders)
{
StringBuilder sb = new StringBuilder();
if (LOGGER.isDebugEnabled())
{
sb.append("Current Node :").append(nNode.getNodeName());
sb.append("|Node Type:").append(nNode.getNodeType());
sb.append("|Node Value:").append(nNode.getNodeValue());
sb.append("|Text Value:" + nNode.getTextContent());
LOGGER.debug(sb.toString());
}
if (nNode.getNodeType() == Node.ELEMENT_NODE)
{
Element eElement = (Element)nNode;
if (hasSubElement(nNode))
{
NodeList nList = nNode.getChildNodes();
Node nodeItem;
for (int temp = 0; temp < nList.getLength(); temp++)
{
nodeItem = nList.item(temp);
parseNode(nodeItem, placerHolders);
}
}
else
{
if (LOGGER.isDebugEnabled())
{
sb.delete(0, sb.length());
sb.append("Tag Name:").append(eElement.getTagName());
sb.append("|Node Name:").append(eElement.getNodeName());
sb.append("|Node Value:").append(eElement.getNodeValue());
sb.append("|Text Content:").append(eElement.getTextContent());
LOGGER.debug(sb.toString());
}
//It's the element which hasn't child element and should be processed
PlaceHolderBean placeHolder = processElement(eElement);
if (null != placeHolder)
{
placerHolders.add(placeHolder);
}
}
}
return placerHolders;
}
private boolean hasSubElement(Node node)
{
if (null == node || Node.ELEMENT_NODE != node.getNodeType())
{
return false;
}
NodeList nList = node.getChildNodes();
Node nodeItem;
for (int temp = 0; temp < nList.getLength(); temp++)
{
nodeItem = nList.item(temp);
if (Node.ELEMENT_NODE == nodeItem.getNodeType())
{
return true;
}
}
return false;
}
protected abstract PlaceHolderBean processElement(Element element);
}
|
<!DOCTYPE html >
<html >
<head>
<title> {gooraye:$f_siteTitle} {gooraye:$f_siteName}</title>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<meta name="keywords" content="{gooraye:$f_metaKeyword}" />
<meta name="description" content="{gooraye:$f_metaDes}" />
<meta http-equiv="MSThemeCompatible" content="Yes" />
<!-- <link rel="stylesheet" type="text/css" href="{gooraye::RES}/css/style_2_common.css" /> -->
<link href="{gooraye::STATICS}/font-awesome/css/font-awesome.min.css" rel="stylesheet" type="text/css" />
<script>var SITEURL='';</script>
<!-- <script src="{gooraye::RES}/js/common.js" type="text/javascript"></script> -->
<script src="{gooraye::STATICS}/jquery-1.9.1.js" type="text/javascript"></script>
<script src="{gooraye::RES}/js/index.js" type="text/javascript"></script>
<link href="{gooraye::RES}/css/style.css" rel="stylesheet" type="text/css" />
<link href="{gooraye::RES}/css/user.css" rel="stylesheet" type="text/css" />
<script type="text/javascript">
$(function(){
initComponent();
})
</script>
<style type="text/css">
.mask{
width: 99999px;
height: 99999px;
background: rgba(85, 85, 85, 0.55);
position: absolute;
z-index: 10;
top: 0px;
}
.goorayealert{
display: none;
background: #f8f8f8;
padding: 15px;
top:100px;
width:460px;
position: absolute;
left: 50%;
z-index: 15;
margin-left: -230px;
}
.alertcontent{
background-color: #fff;
}
.close:hover{
color:#000;
}
.close{
float: right;
font-size: 21px;
font-weight: bold;
line-height: 1;
color: #000;
top:-6px;
text-shadow: 0 1px 0 #fff;
opacity: .2;
filter: alpha(opacity=20);
cursor: pointer;
position: relative;
}
</style>
</head>
<body id="nv_member" class="pg_CURMODULE">
<div class="topbg">
<!-- top START -->
<div class="top">
<!-- toplink START -->
<div class="toplink">
<div class="memberinfo" id="destoon_member">
<a href="{gooraye::U('User/Index/index')}">
<img class="logo" src="{gooraye::RES}/images/logo.png">
</a>
<!-- <img src="{gooraye:$wecha.headerpic}" width="60" height="60">
<strong>{gooraye:$wecha.wxname}</strong><a href="#" target="_blank" class="vipimg vip-icon<php>echo $userinfo['taxisid']-1;</php>" title=""></a> -->
<if condition="$_SESSION[uid]==false">
<else/>
,<a href="{gooraye::U('User/Index/index')}" hidefocus="true" ><span style="color:#f40">{gooraye:$Think.session.uname}</span></a>uid:{gooraye:$Think.session.uid}
<a class="btn btn-small btn-inverse" href="{gooraye::U('System/Admin/logout')}" ><i class="fa fa-power-off " title=""></i></a>
</if>
</div>
<!-- memberinfo END -->
</div>
<!-- toplink END -->
</div>
<!-- top END -->
<!-- wp START -->
<div id="wp" class="wp">
<!-- contentmanage START -->
<div class="contentmanage">
<!-- developer START -->
<div class="developer">
|
<!DOCTYPE html>
<html xmlns="http:
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
<link rel="SHORTCUT ICON" href="../../../../../img/clover.ico" />
<link rel="stylesheet" href="../../../../../aui/css/aui.min.css" media="all"/>
<link rel="stylesheet" href="../../../../../aui/css/aui-experimental.min.css" media="all"/>
<!--[if IE 9]><link rel="stylesheet" href="../../../../../aui/css/aui-ie9.min.css" media="all"/><![endif]-->
<style type="text/css" media="all">
@import url('../../../../../style.css');
@import url('../../../../../tree.css');
</style>
<script src="../../../../../jquery-1.8.3.min.js" type="text/javascript"></script>
<script src="../../../../../aui/js/aui.min.js" type="text/javascript"></script>
<script src="../../../../../aui/js/aui-experimental.min.js" type="text/javascript"></script>
<script src="../../../../../aui/js/aui-soy.min.js" type="text/javascript"></script>
<script src="../../../../../package-nodes-tree.js" type="text/javascript"></script>
<script src="../../../../../clover-tree.js" type="text/javascript"></script>
<script src="../../../../../clover.js" type="text/javascript"></script>
<script src="../../../../../clover-descriptions.js" type="text/javascript"></script>
<script src="../../../../../cloud.js" type="text/javascript"></script>
<title>ABA Route Transit Number Validator 1.0.1-SNAPSHOT</title>
</head>
<body>
<div id="page">
<header id="header" role="banner">
<nav class="aui-header <API key>" role="navigation">
<div class="aui-header-inner">
<div class="aui-header-primary">
<h1 id="logo" class="aui-header-logo <API key>">
<a href="http://openclover.org" title="Visit OpenClover home page"><span class="<API key>">OpenClover</span></a>
</h1>
</div>
<div class="<API key>">
<ul class="aui-nav">
<li id="system-help-menu">
<a class="aui-nav-link" title="Open online documentation" target="_blank"
href="http://openclover.org/documentation">
<span class="aui-icon aui-icon-small aui-iconfont-help"> Help</span>
</a>
</li>
</ul>
</div>
</div>
</nav>
</header>
<div class="aui-page-panel">
<div class="<API key>">
<div class="aui-page-panel-nav <API key>">
<div class="<API key>" style="margin-bottom: 20px;">
<div class="<API key>">
<a href="http://cardatechnologies.com" target="_top">
<div class="aui-avatar aui-avatar-large aui-avatar-project">
<div class="aui-avatar-inner">
<img src="../../../../../img/clover_logo_large.png" alt="Clover icon"/>
</div>
</div>
</a>
</div>
<div class="<API key>" >
<h1>
<a href="http://cardatechnologies.com" target="_top">
ABA Route Transit Number Validator 1.0.1-SNAPSHOT
</a>
</h1>
</div>
</div>
<nav class="aui-navgroup <API key>">
<div class="aui-navgroup-inner">
<ul class="aui-nav">
<li class="">
<a href="../../../../../dashboard.html">Project overview</a>
</li>
</ul>
<div class="aui-nav-heading <API key>">
<strong>Packages</strong>
</div>
<div class="aui-nav project-packages">
<form method="get" action="#" class="aui <API key>">
<input type="text" autocomplete="off" class="package-filter text"
placeholder="Type to filter packages..." name="package-filter" id="package-filter"
title="Start typing package name (or part of the name) to search through the tree. Use arrow keys and the Enter key to navigate."/>
</form>
<p class="<API key> hidden">
<small>No results found.</small>
</p>
<div class="<API key>" data-root-relative="../../../../../" data-package-name="com.cardatechnologies.utils.validators.abaroutevalidator">
<div class="<API key>"></div>
<div class="<API key>"></div>
</div>
</div>
</div>
</nav> </div>
<section class="<API key>">
<div class="<API key>">
<div class="<API key>"><ol class="aui-nav aui-nav-breadcrumbs">
<li><a href="../../../../../dashboard.html"> Project Clover database Sat Aug 7 2021 12:29:33 MDT</a></li>
<li><a href="test-pkg-summary.html">Package com.cardatechnologies.utils.validators.abaroutevalidator</a></li>
<li><a href="<API key>.html">Class <API key></a></li>
</ol></div>
<h1 class="aui-h2-clover">
Test <API key>
</h1>
<table class="aui">
<thead>
<tr>
<th>Test</th>
<th><label title="The test result. Either a Pass, Fail or Error.">Status</label></th>
<th><label title="When the test execution was started">Start time</label></th>
<th><label title="The total time in seconds taken to run this test.">Time (seconds)</label></th>
<th><label title="A failure or error message if the test is not successful.">Message</label></th>
</tr>
</thead>
<tbody>
<tr>
<td>
<a href="../../../../../com/cardatechnologies/utils/validators/abaroutevalidator/<API key>.html?line=44681#src-44681" ><API key></a>
</td>
<td>
<span class="sortValue">1</span><span class="aui-lozenge aui-lozenge-success">PASS</span>
</td>
<td>
7 Aug 12:33:07
</td>
<td>
0.0 </td>
<td>
<div></div>
<div class="errorMessage"></div>
</td>
</tr>
</tbody>
</table>
<div> </div>
<table class="aui aui-table-sortable">
<thead>
<tr>
<th style="white-space:nowrap;"><label title="A class that was directly hit by this test.">Target Class</label></th>
<th colspan="4"><label title="The percentage of coverage contributed by each single test.">Coverage contributed by</label> <API key></th>
</tr>
</thead>
<tbody>
<tr>
<td>
<span class="sortValue">com.cardatechnologies.utils.validators.abaroutevalidator.AbaRouteValidator</span>
  <a href="../../../../../com/cardatechnologies/utils/validators/abaroutevalidator/AbaRouteValidator.html?id=40441#AbaRouteValidator" title="AbaRouteValidator" name="sl-47">com.cardatechnologies.utils.validators.abaroutevalidator.AbaRouteValidator</a>
</td>
<td>
<span class="sortValue">0.7352941</span>73.5%
</td>
<td class="align-middle" style="width: 100%" colspan="3">
<div>
<div title="73.5% Covered" style="min-width:40px;" class="barNegative contribBarNegative contribBarNegative"><div class="barPositive contribBarPositive contribBarPositive" style="width:73.5%"></div></div></div> </td>
</tr>
</tbody>
</table>
</div> <!-- class="<API key>" -->
<footer id="footer" role="contentinfo">
<section class="footer-body">
<ul>
<li>
Report generated by <a target="_new" href="http://openclover.org">OpenClover</a> v 4.4.1
on Sat Aug 7 2021 12:49:26 MDT using coverage data from Sat Aug 7 2021 12:47:23 MDT.
</li>
</ul>
<ul>
<li>OpenClover is free and open-source software. </li>
</ul>
</section>
</footer> </section> <!-- class="<API key>" -->
</div> <!-- class="<API key>" -->
</div> <!-- class="aui-page-panel" -->
</div> <!-- id="page" -->
</body>
</html>
|
package com.example;
public interface Movable {
public void moveLeft();
public void moveRight();
}
|
# AUTOGENERATED FILE
FROM balenalib/<API key>:3.13-run
ENV GO_VERSION 1.16.14
# set up nsswitch.conf for Go's "netgo" implementation
# - docker run --rm debian:stretch grep '^hosts:' /etc/nsswitch.conf
RUN [ ! -e /etc/nsswitch.conf ] && echo 'hosts: files dns' > /etc/nsswitch.conf
# gcc for cgo
RUN apk add --no-cache git gcc ca-certificates
RUN fetchDeps='curl' \
&& set -x \
&& apk add --no-cache $fetchDeps \
&& mkdir -p /usr/local/go \
&& curl -SLO "http://resin-packages.s3.amazonaws.com/golang/v$GO_VERSION/go$GO_VERSION.<API key>.tar.gz" \
&& echo "<SHA256-like> go$GO_VERSION.<API key>.tar.gz" | sha256sum -c - \
&& tar -xzf "go$GO_VERSION.<API key>.tar.gz" -C /usr/local/go --strip-components=1 \
&& rm -f go$GO_VERSION.<API key>.tar.gz
ENV GOROOT /usr/local/go
ENV GOPATH /go
ENV PATH $GOPATH/bin:/usr/local/go/bin:$PATH
RUN mkdir -p "$GOPATH/src" "$GOPATH/bin" && chmod -R 777 "$GOPATH"
WORKDIR $GOPATH
CMD ["echo","'No CMD command was set in Dockerfile! Details about CMD command could be found in Dockerfile Guide section in our Docs. Here's the link: https://balena.io/docs"]
RUN curl -SLO "https://raw.githubusercontent.com/balena-io-library/base-images/<SHA1-like>/scripts/assets/tests/test-stack@golang.sh" \
&& echo "Running test-stack@golang" \
&& chmod +x test-stack@golang.sh \
&& bash test-stack@golang.sh \
&& rm -rf test-stack@golang.sh
RUN [ ! -d /.balena/messages ] && mkdir -p /.balena/messages; echo $'Here are a few details about this Docker image (For more information please visit https:
RUN echo $'#!/bin/bash\nbalena-info\nbusybox ln -sf /bin/busybox /bin/sh\n/bin/sh "$@"' > /bin/sh-shim \
&& chmod +x /bin/sh-shim \
&& ln -f /bin/sh /bin/sh.real \
&& ln -f /bin/sh-shim /bin/sh
|
package ch.unibe.scg.regex;
import static java.util.Collections.singleton;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.SortedSet;
import java.util.TreeSet;
import ch.unibe.scg.regex.ParserProvider.Node;
import ch.unibe.scg.regex.ParserProvider.Node.Basic;
import ch.unibe.scg.regex.ParserProvider.Node.Group;
import ch.unibe.scg.regex.ParserProvider.Node.NonGreedyStar;
import ch.unibe.scg.regex.ParserProvider.Node.Optional;
import ch.unibe.scg.regex.ParserProvider.Node.Plus;
import ch.unibe.scg.regex.ParserProvider.Node.PositiveSet;
import ch.unibe.scg.regex.ParserProvider.Node.SetItem;
import ch.unibe.scg.regex.ParserProvider.Node.Simple;
import ch.unibe.scg.regex.ParserProvider.Node.Star;
import ch.unibe.scg.regex.ParserProvider.Node.Union;
import ch.unibe.scg.regex.TNFA.Builder;
import ch.unibe.scg.regex.Transition.Priority;
/**
* Not thread-safe! Use only from one thread at a time!
*
* @author nes
*/
class RegexToNFA {
final InputRangeCleanup inputRangeCleanup = new InputRangeCleanup();
TNFA convert(final Node node) {
Collection<InputRange> allInputRanges = new ArrayList<>();
allInputRanges.add(InputRange.ANY); // All regexes contain this implicitly.
findRanges(node, allInputRanges);
final Builder builder = Builder.make(allInputRanges);
builder.<API key>(builder.captureGroupMaker.entireMatch);
final MiniAutomaton m =
<API key>(builder, builder.captureGroupMaker.entireMatch);
final MiniAutomaton a = make(m, builder, node, builder.captureGroupMaker.entireMatch);
final State endTagger = builder.makeState();
builder.addEndTagTransition(a.finishing, endTagger, builder.captureGroupMaker.entireMatch,
Priority.NORMAL);
builder.setAsAccepting(endTagger);
return builder.build();
}
private void findRanges(Node n, Collection<InputRange> out) {
if (n instanceof Node.SetItem) {
out.add(((SetItem) n).inputRange);
}
for (Node c : n.getChildren()) {
findRanges(c, out);
}
}
static class MiniAutomaton {
final Collection<State> finishing;
final Collection<State> initial;
MiniAutomaton(final Collection<State> initial, final Collection<State> finishing) {
if (initial.iterator().next() == null) {
assert false;
}
this.initial = initial;
this.finishing = finishing;
}
MiniAutomaton(final Collection<State> initial, final State finishing) {
this(initial, singleton(finishing));
}
@Override
public String toString() {
return "" + initial + " -> " + finishing;
}
}
MiniAutomaton make(final MiniAutomaton last, final Builder builder, final Node node,
CaptureGroup captureGroup) {
MiniAutomaton ret;
if (node instanceof Node.Any) {
ret = makeAny(last, builder);
} else if (node instanceof Node.Char) {
ret = makeChar(last, builder, (Node.Char) node);
} else if (node instanceof Node.Simple) {
ret = makeSimple(last, builder, (Node.Simple) node, captureGroup);
} else if (node instanceof Node.Optional) {
ret = makeOptional(last, builder, (Node.Optional) node, captureGroup);
} else if (node instanceof Node.NonGreedyStar) {
ret = makeNonGreedyStar(last, builder, (Node.NonGreedyStar) node, captureGroup);
} else if (node instanceof Node.Star) {
ret = makeStar(last, builder, (Star) node, captureGroup);
} else if (node instanceof Node.Plus) {
ret = makePlus(last, builder, (Node.Plus) node, captureGroup);
} else if (node instanceof Node.Group) {
ret = makeGroup(last, builder, (Node.Group) node, captureGroup);
} else if (node instanceof Node.Eos) {
ret = makeEos(last, builder);
} else if (node instanceof Node.Char) {
ret = makeChar(last, builder, (Node.Char) node);
} else if (node instanceof Node.PositiveSet) {
ret = makePositiveSet(last, builder, (Node.PositiveSet) node);
} else if (node instanceof Node.Union) {
ret = makeUnion(last, builder, (Node.Union) node, captureGroup);
} else {
throw new AssertionError("Unknown node type: " + node);
}
assert !ret.initial.contains(null);
assert !ret.finishing.contains(null);
return ret;
}
MiniAutomaton makeAny(final MiniAutomaton last, final Builder builder) {
final State a = builder.makeState();
builder.<API key>(InputRange.ANY, last.finishing, a);
return new MiniAutomaton(last.finishing, a);
}
MiniAutomaton makeChar(final MiniAutomaton last, final Builder b, final Node.Char character) {
final State a = b.makeState();
final MiniAutomaton ret = new MiniAutomaton(last.finishing, a);
b.<API key>(character.inputRange, ret.initial, a);
return ret;
}
MiniAutomaton makeEos(final MiniAutomaton last, final Builder builder) {
final State a = builder.makeState();
builder.<API key>(InputRange.EOS, last.finishing, a);
return new MiniAutomaton(last.finishing, a);
}
MiniAutomaton makeGroup(final MiniAutomaton last, final Builder builder, final Group group,
CaptureGroup parentCaptureGroup) {
final CaptureGroup cg = builder.makeCaptureGroup(parentCaptureGroup);
builder.<API key>(cg);
final State startGroup = builder.makeState();
builder.<API key>(last.finishing, startGroup, cg, Priority.NORMAL);
final MiniAutomaton startGroupAutomaton = new MiniAutomaton(singleton(startGroup), singleton(startGroup));
final MiniAutomaton body = make(startGroupAutomaton, builder, group.body, cg);
final State endTag = builder.makeState();
builder.addEndTagTransition(body.finishing, endTag, cg, Priority.NORMAL);
return new MiniAutomaton(last.finishing, endTag);
}
MiniAutomaton <API key>(final Builder builder, CaptureGroup entireMatch) {
final State init = builder.makeInitialState();
final State startTagger = builder.makeState();
builder.<API key>(singleton(init), startTagger, entireMatch, Priority.NORMAL);
return new MiniAutomaton(singleton(init), singleton(startTagger));
}
MiniAutomaton makeOptional(final MiniAutomaton last, final Builder builder,
final Optional optional, CaptureGroup captureGroup) {
final MiniAutomaton ma = make(last, builder, optional.elementary, captureGroup);
final List<State> f = new ArrayList<>(last.finishing);
f.addAll(ma.finishing);
return new MiniAutomaton(last.finishing, f);
}
MiniAutomaton makePlus(final MiniAutomaton last, final Builder builder, final Plus plus,
CaptureGroup captureGroup) {
final MiniAutomaton inner = make(last, builder, plus.elementary, captureGroup);
Collection<State> out = singleton(builder.makeState());
builder.<API key>(inner.finishing, out, Priority.LOW);
final MiniAutomaton ret = new MiniAutomaton(last.finishing, out);
builder.<API key>(inner.finishing,
inner.initial, Priority.NORMAL);
return ret;
}
MiniAutomaton makeUnion(MiniAutomaton last, Builder builder, Union union,
CaptureGroup captureGroup) {
MiniAutomaton left = make(last, builder, union.left, captureGroup);
MiniAutomaton right = make(last, builder, union.right, captureGroup);
Collection<State> out = singleton(builder.makeState());
builder.<API key>(left.finishing, out, Priority.NORMAL);
builder.<API key>(right.finishing, out, Priority.LOW);
return new MiniAutomaton(last.finishing, out);
}
MiniAutomaton makePositiveSet(final MiniAutomaton last, final Builder builder,
final PositiveSet set) {
final List<SetItem> is = set.items;
final SortedSet<InputRange> ranges = new TreeSet<>();
for (final SetItem i : is) {
ranges.add(i.inputRange);
}
final List<InputRange> rangesList = new ArrayList<>(ranges);
final List<InputRange> cleanedRanges = inputRangeCleanup.cleanUp(rangesList);
final State a = builder.makeState();
for (InputRange range : cleanedRanges) {
builder.<API key>(range, last.finishing, a);
}
return new MiniAutomaton(last.finishing, a);
}
MiniAutomaton makeSimple(final MiniAutomaton last, final Builder b, final Simple simple,
CaptureGroup captureGroup) {
final List<? extends Basic> bs = simple.basics;
MiniAutomaton lm = last;
for (final Basic e : bs) {
lm = make(lm, b, e, captureGroup);
}
return new MiniAutomaton(last.finishing, lm.finishing);
}
MiniAutomaton makeNonGreedyStar(MiniAutomaton last, Builder builder, NonGreedyStar nonGreedyStar,
CaptureGroup captureGroup) {
// Make start state and connect.
State start = builder.makeState();
builder.<API key>(last.finishing, singleton(start), Priority.NORMAL);
// Make inner machine.
MiniAutomaton innerLast = new MiniAutomaton(last.finishing, start);
final MiniAutomaton inner = make(innerLast, builder, nonGreedyStar.elementary, captureGroup);
// Connect inner machine back to start.
builder.<API key>(inner.finishing, singleton(start), Priority.LOW);
// Make and connect `out` state.
State out = builder.makeState();
builder.<API key>(singleton(start), singleton(out), Priority.NORMAL);
return new MiniAutomaton(last.finishing, out);
}
MiniAutomaton makeStar(final MiniAutomaton last, final Builder builder, final Star star,
CaptureGroup captureGroup) {
// Make start state and connect.
State start = builder.makeState();
builder.<API key>(last.finishing, singleton(start), Priority.NORMAL);
// Make inner machine.
MiniAutomaton innerLast = new MiniAutomaton(singleton(start), start);
final MiniAutomaton inner = make(innerLast, builder, star.elementary, captureGroup);
// Connect inner machine back to start.
builder.<API key>(inner.finishing, singleton(start), Priority.NORMAL);
// Make and connect `out` state.
State out = builder.makeState();
builder.<API key>(singleton(start), singleton(out), Priority.LOW);
return new MiniAutomaton(last.finishing, out);
}
}
|
package com.siqisoft.stone.admin.dict.controller;
import java.util.List;
import org.siqisource.stone.dict.model.Dict;
import org.siqisource.stone.dict.service.DictService;
import org.siqisource.stone.orm.condition.Condition;
import org.siqisource.stone.ui.AjaxResponse;
import org.siqisource.stone.ui.Notify;
import org.siqisource.stone.ui.easyui.PagedRows;
import org.siqisource.stone.ui.easyui.Paging;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import com.siqisoft.stone.admin.dict.service.<API key>;
@Controller
public class DictController {
@Autowired
DictService service;
@RequestMapping("/dict/DictList.do")
public String list(Model model) {
return "dict/DictList";
}
@RequestMapping("/dict/dictListData.do")
@ResponseBody
public PagedRows<Dict> listData(DictQueryForm dictQueryForm, Paging paging) {
Condition condition = <API key>.listCondition(dictQueryForm);
int count = service.count(condition);
List<Dict> dictList = service.list(condition, paging.getRowBounds());
return new PagedRows<Dict>(count, dictList);
}
@RequestMapping("/dict/DictRead.do")
public String read(String code, Model model) {
Dict dict = service.read(code);
model.addAttribute("dict", dict);
return "dict/DictRead";
}
@RequestMapping("/dict/DictAddInit.do")
public String addInit(Dict dict, Model model) {
return "dict/DictAdd";
}
@RequestMapping("/dict/DictAdd.do")
public String add(Dict dict, Model model) {
service.insert(dict);
return this.read(dict.getCode(), model);
}
@RequestMapping("/dict/dictDelete.do")
@ResponseBody
public AjaxResponse delete(String[] codeList, Model model) {
if (codeList != null) {
service.deleteBatch(codeList);
}
return new Notify(""+codeList.length+"");
}
@RequestMapping("/dict/DictEditInit.do")
public String editInit(String code, Model model) {
Dict dict = service.read(code);
model.addAttribute("dict", dict);
return "dict/DictEdit";
}
@RequestMapping("/dict/DictEdit.do")
public String edit(Dict dict, Model model) {
service.update(dict);
return this.read(dict.getCode(), model);
}
}
|
<?php
if (!defined('BASEPATH')) exit('No direct script access allowed');
class MY_Model extends CI_Model {
var $table = "";
function __construct() {
parent::__construct();
}
/**
* Insere um registro na tabela
*
* @param array $data Dados a serem inseridos
*
* @return boolean
*/
function Inserir($data) {
if(!isset($data))
return false;
return $this->db->insert($this->table, $data);
}
/**
* Recupera um registro a partir de um ID
*
* @param integer $id ID do registro a ser recuperado
*
* @return array
*/
function GetById($id) {
if(is_null($id))
return false;
$this->db->where('id', $id);
$query = $this->db->get($this->table);
if ($query->num_rows() > 0) {
return $query->row_array();
} else {
return null;
}
}
function GetAll($sort = 'id', $order = 'asc') {
// $this->db->where('servico', 'Website');
$this->db->order_by($sort, $order);
$query = $this->db->get($this->table);
if ($query->num_rows() > 0) {
return $query->result_array();
} else {
return null;
}
}
function GetAllFace($sort = 'id', $order = 'asc') {
$this->db->where("servico like '%Facebook%'");
$this->db->order_by($sort, $order);
$query = $this->db->get($this->table);
if ($query->num_rows() > 0) {
return $query->result_array();
} else {
return null;
}
}
function GetAllSite($sort = 'id', $order = 'asc') {
$this->db->where("servico like '%Website%'");
$this->db->order_by($sort, $order);
$query = $this->db->get($this->table);
if ($query->num_rows() > 0) {
return $query->result_array();
} else {
return null;
}
}
function GetAllMail($sort = 'id', $order = 'asc') {
$this->db->where("servico like '%Mail%'");
$this->db->order_by($sort, $order);
$query = $this->db->get($this->table);
if ($query->num_rows() > 0) {
return $query->result_array();
} else {
return null;
}
}
/**
* Atualiza um registro na tabela
*
* @param integer $int ID do registro a ser atualizado
*
* @param array $data Dados a serem inseridos
*
* @return boolean
*/
function Atualizar($id, $data) {
if(is_null($id) || !isset($data))
return false;
$this->db->where('id', $id);
return $this->db->update($this->table, $data);
}
/**
* Remove um registro na tabela
*
* @param integer $int ID do registro a ser removido
*
*
* @return boolean
*/
function Excluir($id) {
if(is_null($id))
return false;
$this->db->where('id', $id);
return $this->db->delete($this->table);
}
}
/* End of file */
|
package com.nguyenmanhtuan.benhandientu;
import android.app.Activity;
import android.content.Intent;
import android.content.res.Configuration;
import android.content.res.Resources;
import android.os.Bundle;
import android.util.DisplayMetrics;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;
import java.util.HashMap;
import java.util.Locale;
import com.nguyenmanhtuan.utils.DatabaseHandler;
public class RegisteredActivity extends Activity {
private Locale myLocale;
/**
* Called when the activity is first created.
*/
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_registered);
DatabaseHandler db = new DatabaseHandler(<API key>());
HashMap<String, String> user = new HashMap<String, String>();
user = db.getUserDetails();
/**
* Displays the registration details in Text view
**/
final TextView fname = (TextView) findViewById(R.id.fname);
final TextView lname = (TextView) findViewById(R.id.lname);
final TextView uname = (TextView) findViewById(R.id.uname);
final TextView email = (TextView) findViewById(R.id.email);
final TextView address = (TextView) findViewById(R.id.tvadd);
final TextView phonenumber = (TextView) findViewById(R.id.tvphone);
final TextView birthyear = (TextView) findViewById(R.id.tvBirthyear);
final TextView created_at = (TextView) findViewById(R.id.regat);
fname.setText(user.get("fname"));
lname.setText(user.get("lname"));
uname.setText(user.get("uname"));
email.setText(user.get("email"));
address.setText(user.get("address"));
phonenumber.setText(user.get("phonenumber"));
birthyear.setText(user.get("birthyear"));
created_at.setText(user.get("created_at"));
Button login = (Button) findViewById(R.id.login);
login.setOnClickListener(new View.OnClickListener() {
public void onClick(View view) {
Intent myIntent = new Intent(view.getContext(), LoginActivity.class);
<API key>(myIntent, 0);
finish();
}
});
}
public void setLocale(String lang) {
myLocale = new Locale(lang);
Resources res = getResources();
DisplayMetrics dm = res.getDisplayMetrics();
Configuration conf = res.getConfiguration();
conf.locale = myLocale;
res.updateConfiguration(conf, dm);
Intent refresh = new Intent(this, RegisteredActivity.class);
startActivity(refresh);
}
}
|
package com.vertabelo.mobileorm.myplaces.orm.gen;
public class AddressViewDAOImpl
extends com.vertabelo.mobileorm.myplaces.orm.runtime.dao.BaseDAO<AddressView>
implements AddressViewDAO {
public AddressViewDAOImpl(com.vertabelo.mobileorm.myplaces.orm.runtime.util.SQLiteDataSource dataSource) {
super(dataSource);
}
public AddressViewDAOImpl(com.vertabelo.mobileorm.myplaces.orm.runtime.util.SQLiteDataSource dataSource,
com.vertabelo.mobileorm.myplaces.orm.runtime.util.DAOMonitor daoMonitor) {
super(dataSource, daoMonitor);
}
@Override
public Class<AddressView> getPojoClass() {
return POJO_CLASS;
}
@Override
public com.vertabelo.mobileorm.myplaces.orm.runtime.query.TableExpression getTableExpression() {
return TABLE_EXPRESSION;
}
@Override
public com.vertabelo.mobileorm.myplaces.orm.runtime.util.ResultSetHandler getResultSetHandler() {
return RESULT_SET_HANDLER;
}
@Override
public java.util.List<AddressView> getAddressViewList() {
com.vertabelo.mobileorm.myplaces.orm.runtime.query.SelectQuery query =
new com.vertabelo.mobileorm.myplaces.orm.runtime.query.SelectQuery(TABLE_EXPRESSION);
com.vertabelo.mobileorm.myplaces.orm.runtime.dao.<API key><AddressView>
<API key> = select(query, RESULT_SET_HANDLER);
return <API key>.getObjectList();
}
@Override
public java.util.List<AddressView> getAddressViewList(com.vertabelo.mobileorm.myplaces.orm.runtime.query.AExp orderBy) {
com.vertabelo.mobileorm.myplaces.orm.runtime.query.SelectQuery query =
new com.vertabelo.mobileorm.myplaces.orm.runtime.query.SelectQuery(TABLE_EXPRESSION);
query.orderBy(orderBy);
com.vertabelo.mobileorm.myplaces.orm.runtime.dao.<API key><AddressView>
<API key> = select(query, RESULT_SET_HANDLER);
return <API key>.getObjectList();
}
@Override
public java.util.List<AddressView> getAddressViewList(com.vertabelo.mobileorm.myplaces.orm.runtime.query.AExp orderBy, com.vertabelo.mobileorm.myplaces.orm.runtime.query.OrderByDirection asc) {
com.vertabelo.mobileorm.myplaces.orm.runtime.query.SelectQuery query =
new com.vertabelo.mobileorm.myplaces.orm.runtime.query.SelectQuery(TABLE_EXPRESSION);
query.orderBy(orderBy, asc);
com.vertabelo.mobileorm.myplaces.orm.runtime.dao.<API key><AddressView>
<API key> = select(query, RESULT_SET_HANDLER);
return <API key>.getObjectList();
}
@Override
public java.util.List<AddressView> getAddressViewList(com.vertabelo.mobileorm.myplaces.orm.runtime.query.LExp where) {
com.vertabelo.mobileorm.myplaces.orm.runtime.query.SelectQuery query =
new com.vertabelo.mobileorm.myplaces.orm.runtime.query.SelectQuery(TABLE_EXPRESSION);
query.setWhere(where);
com.vertabelo.mobileorm.myplaces.orm.runtime.dao.<API key><AddressView>
<API key> = select(query, RESULT_SET_HANDLER);
return <API key>.getObjectList();
}
@Override
public java.util.List<AddressView> getAddressViewList(com.vertabelo.mobileorm.myplaces.orm.runtime.query.LExp where,
com.vertabelo.mobileorm.myplaces.orm.runtime.query.AExp orderBy) {
com.vertabelo.mobileorm.myplaces.orm.runtime.query.SelectQuery query =
new com.vertabelo.mobileorm.myplaces.orm.runtime.query.SelectQuery(TABLE_EXPRESSION);
query.setWhere(where);
query.orderBy(orderBy);
com.vertabelo.mobileorm.myplaces.orm.runtime.dao.<API key><AddressView>
<API key> = select(query, RESULT_SET_HANDLER);
return <API key>.getObjectList();
}
@Override
public java.util.List<AddressView> getAddressViewList(com.vertabelo.mobileorm.myplaces.orm.runtime.query.LExp where,
com.vertabelo.mobileorm.myplaces.orm.runtime.query.AExp orderBy, com.vertabelo.mobileorm.myplaces.orm.runtime.query.OrderByDirection asc) {
com.vertabelo.mobileorm.myplaces.orm.runtime.query.SelectQuery query =
new com.vertabelo.mobileorm.myplaces.orm.runtime.query.SelectQuery(TABLE_EXPRESSION);
query.setWhere(where);
query.orderBy(orderBy, asc);
com.vertabelo.mobileorm.myplaces.orm.runtime.dao.<API key><AddressView>
<API key> = select(query, RESULT_SET_HANDLER);
return <API key>.getObjectList();
}
@Override
public Long getCount() {
com.vertabelo.mobileorm.myplaces.orm.runtime.query.SelectQuery query =
new com.vertabelo.mobileorm.myplaces.orm.runtime.query.SelectQuery(TABLE_EXPRESSION,
com.vertabelo.mobileorm.myplaces.orm.runtime.query.AExp.fun("COUNT",
com.vertabelo.mobileorm.myplaces.orm.runtime.query.AExp.ASTERISK));
java.util.List<Long> list = select(query, new com.vertabelo.mobileorm.myplaces.orm.runtime.util.handlers.<API key>()).getObjectList();
if (list.size() > 1) {
throw new RuntimeException("More than one object returned");
} else if (list.size() == 1) {
return list.get(0);
} else {
throw new RuntimeException("Cannot retrieve count() method result");
}
}
@Override
public Long getCount(com.vertabelo.mobileorm.myplaces.orm.runtime.query.LExp where) {
com.vertabelo.mobileorm.myplaces.orm.runtime.query.SelectQuery query =
new com.vertabelo.mobileorm.myplaces.orm.runtime.query.SelectQuery(TABLE_EXPRESSION,
com.vertabelo.mobileorm.myplaces.orm.runtime.query.AExp.fun("COUNT",
com.vertabelo.mobileorm.myplaces.orm.runtime.query.AExp.ASTERISK));
query.setWhere(where);
java.util.List<Long> list = select(query, new com.vertabelo.mobileorm.myplaces.orm.runtime.util.handlers.<API key>()).getObjectList();
if (list.size() > 1) {
throw new RuntimeException("More than one object returned");
} else if (list.size() == 1) {
return list.get(0);
} else {
throw new RuntimeException("Cannot retrieve count() method result");
}
}
}
|
package com.intellij.codeInsight.generation;
import com.intellij.codeInsight.AnnotationUtil;
import com.intellij.codeInsight.intention.AddAnnotationPsiFix;
import com.intellij.openapi.extensions.ExtensionPointName;
import com.intellij.openapi.module.Module;
import com.intellij.openapi.module.ModuleUtilCore;
import com.intellij.openapi.project.Project;
import com.intellij.psi.*;
import com.intellij.psi.search.GlobalSearchScope;
import com.intellij.util.ArrayUtil;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import static com.intellij.codeInsight.AnnotationUtil.CHECK_EXTERNAL;
import static com.intellij.codeInsight.AnnotationUtil.CHECK_TYPE;
/**
* @author anna
*/
public interface <API key> {
ExtensionPointName<<API key>> EP_NAME = ExtensionPointName.create("com.intellij.<API key>");
/**
* Returns annotations which should be copied from a source to an implementation (by default, no annotations are copied).
*/
default String[] getAnnotations(@NotNull PsiFile file) {
//noinspection deprecation
return getAnnotations(file.getProject());
}
/**
* @deprecated Use {@link #getAnnotations(PsiFile)}
*/
@Deprecated
String[] getAnnotations(Project project);
@Deprecated
@NotNull
default String[] annotationsToRemove(Project project, @NotNull String fqName) {
return ArrayUtil.EMPTY_STRING_ARRAY;
}
/** Perform post processing on the annotations, such as deleting or renaming or otherwise updating annotations in the override */
default void cleanup(<API key> source, @Nullable PsiElement targetClass, <API key> target) {
}
static void <API key>(<API key> source, @Nullable PsiElement targetClass, <API key> target) {
Module module = ModuleUtilCore.<API key>(targetClass != null ? targetClass : target);
GlobalSearchScope moduleScope = module != null ? GlobalSearchScope.<API key>(module) : null;
Project project = target.getProject();
JavaPsiFacade facade = JavaPsiFacade.getInstance(project);
for (<API key> each : EP_NAME.getExtensionList()) {
for (String annotation : each.getAnnotations(target.getContainingFile())) {
if (moduleScope != null && facade.findClass(annotation, moduleScope) == null) continue;
int flags = CHECK_EXTERNAL | CHECK_TYPE;
if (AnnotationUtil.isAnnotated(source, annotation, flags) && !AnnotationUtil.isAnnotated(target, annotation, flags)) {
each.transferToTarget(annotation, source, target);
}
}
}
for (<API key> each : EP_NAME.getExtensionList()) {
each.cleanup(source, targetClass, target);
}
}
default void transferToTarget(String annotation, <API key> source, <API key> target) {
PsiModifierList modifierList = target.getModifierList();
assert modifierList != null : target;
PsiAnnotation srcAnnotation = AnnotationUtil.findAnnotation(source, annotation);
PsiNameValuePair[] valuePairs = srcAnnotation != null ? srcAnnotation.getParameterList().getAttributes() : PsiNameValuePair.EMPTY_ARRAY;
AddAnnotationPsiFix.<API key>(annotation, valuePairs, modifierList);
}
}
|
package com.chisw.work.addressbook.test;
import com.chisw.work.addressbook.Data.GroupData;
import com.chisw.work.addressbook.Data.Groups;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
import static org.hamcrest.CoreMatchers.equalTo;
import static org.hamcrest.MatcherAssert.assertThat;
public class <API key> extends TestBase {
@BeforeMethod
public void checkPreconditions() {
if (app.db().groups().size() == 0) {
app.goTo().groupPage();
app.groups().<API key>();
}
}
@Test
public void <API key>() {
Groups before = app.db().groups();
GroupData modifiedGroup = before.iterator().next();
GroupData group = new GroupData()
.withId(modifiedGroup.getId()).withGroupName("test 258").withGroupLogo("Logo 123").withGroupComment("Comment 12345");
app.goTo().groupPage();
app.groups().modifyGroup(group);
assertThat(app.groups().count(),equalTo(before.size()));
Groups after = app.db().groups();
assertThat(after, equalTo(before.withoutAdded(modifiedGroup).withAdded(group)));
<API key>();
}
}
|
package io.omengye.common.utils.constants;
public class Constants {
private Constants(){}
public static final String RESULT_FLAG = "flag";
}
|
#ifndef LAYER_H_INCLUDED
#define LAYER_H_INCLUDED
#include "basicresource.h"
#include "Drawable.h"
class Layer : public Drawable
{
private:
void transformation() override;
void onDraw() override;
void postDraw() override;
public:
Layer():
Drawable()
{
}
};
#endif // LAYER_H_INCLUDED
|
import type { PeerInfo } from '@dlghq/dialog-types';
import type { AvatarSize } from '../Avatar/getAvatarSize';
import type { Gradient } from '../Avatar/getAvatarColor';
import React, { PureComponent } from 'react';
import classNames from 'classnames';
import getAvatarSize from '../Avatar/getAvatarSize';
import getAvatarText from '../Avatar/getAvatarText';
import getAvatarColor from '../Avatar/getAvatarColor';
import createSequence from '../../utils/createSequence';
import styles from '../PeerAvatar/PeerAvatar.css';
export type Props = {
className?: string,
peerBig: PeerInfo,
peerSmall: PeerInfo,
size: AvatarSize,
onClick?: (event: SyntheticMouseEvent) => any
};
type DefaultProps = {
size: AvatarSize
};
const seq = createSequence();
class DoublePeerAvatar extends PureComponent<DefaultProps, Props, void> {
id: string;
ids: {
big: string,
clip: string,
small: string
};
static defaultProps = {
size: 'medium'
};
constructor(props: Props) {
super(props);
this.id = 'double_peer_avatar_' + seq.next();
this.ids = {
big: `${this.id}_big`,
clip: `${this.id}_big_clip`,
small: `${this.id}_small`
};
}
getAvatarSize(): number {
return getAvatarSize(this.props.size);
}
renderDefsBig(): React.Element<any> {
if (this.props.peerBig.avatar) {
return (
<pattern id={this.ids.big} width="100%" height="100%" patternUnits="userSpaceOnUse">
<image
x="0"
y="0"
width="100px"
height="100px"
xlinkHref={this.props.peerBig.avatar}
/>
</pattern>
);
}
const colors: Gradient = getAvatarColor(this.props.peerBig.placeholder);
return (
<linearGradient
id={this.ids.big}
gradientUnits="userSpaceOnUse"
x1="6.79%"
y1="105.31%"
x2="93.21%"
y2="-5.31%"
>
<stop stopColor={colors.payload.from} />
<stop offset="1" stopColor={colors.payload.to} />
</linearGradient>
);
}
renderClipMaskBig(): React.Element<any> {
return (
<clipPath id={this.ids.clip}>
<path
// <API key>
d="M58.2070074,99.3297063 C55.5367715,99.7706374 52.795171,100 50,100 C22.3857625,100 0,77.6142375 0,50 C0,22.3857625 22.3857625,0 50,0 C77.6142375,0 100,22.3857625 100,50 C100,52.795171 99.7706374,55.5367715 99.3297063,58.2070074 C94.8434182,55.5348957 89.6009561,54 84,54 C67.4314575,54 54,67.4314575 54,84 C54,89.6009561 55.5348957,94.8434182 58.2070074,99.3297063 Z"
/>
</clipPath>
);
}
renderDefsSmall(): React.Element<any> {
if (this.props.peerSmall.avatar) {
return (
<pattern
id={this.ids.small}
width="100%"
height="100%"
x="58"
y="58"
patternUnits="userSpaceOnUse"
>
<image
x="0"
y="0"
width="100px"
height="100px"
xlinkHref={this.props.peerSmall.avatar}
transform="scale(0.507046569,0.507046569)"
/>
</pattern>
);
}
const colors: Gradient = getAvatarColor(this.props.peerSmall.placeholder);
return (
<linearGradient
id={this.ids.small}
gradientUnits="userSpaceOnUse"
x1="6.79%"
y1="105.31%"
x2="93.21%"
y2="-5.31%"
>
<stop stopColor={colors.payload.from} />
<stop offset="1" stopColor={colors.payload.to} />
</linearGradient>
);
}
renderSmallAvatar(): React.Element<any> {
return (
<circle cx="84" cy="84" r="25" fill={`url(#${this.ids.small})`} />
);
}
renderBigAvatar(): React.Element<any> {
return (
<path
// <API key>
d="M58.2070074,99.3297063 C55.5367715,99.7706374 52.795171,100 50,100 C22.3857625,100 0,77.6142375 0,50 C0,22.3857625 22.3857625,0 50,0 C77.6142375,0 100,22.3857625 100,50 C100,52.795171 99.7706374,55.5367715 99.3297063,58.2070074 C94.8434182,55.5348957 89.6009561,54 84,54 C67.4314575,54 54,67.4314575 54,84 C54,89.6009561 55.5348957,94.8434182 58.2070074,99.3297063 Z"
fill={`url(#${this.ids.big})`}
/>
);
}
renderPeerSmallText(): ?React.Element<any> {
if (this.props.peerSmall.avatar) {
return null;
}
const size = this.getAvatarSize();
const text = size >= 20 ? getAvatarText(this.props.peerSmall.title) : null;
const twoChars = Boolean(text && text.length !== 1);
const textStyles = {
fontSize: twoChars ? 20 : 24
};
return (
<text
className={styles.text}
x="84"
y="84"
textAnchor="middle"
alignmentBaseline="central"
dominantBaseline="central"
style={textStyles}
>
{text}
</text>
);
}
renderPeerBigText(): ?React.Element<any> {
if (this.props.peerBig.avatar) {
return null;
}
const size = this.getAvatarSize();
const text = size >= 20 ? getAvatarText(this.props.peerBig.title) : null;
const twoChars = Boolean(text && text.length !== 1);
const textStyles = {
fontSize: twoChars ? 38 : 48
};
return (
<text
className={styles.text}
x="50"
y="50"
textAnchor="middle"
alignmentBaseline="central"
dominantBaseline="central"
style={textStyles}
clipPath={`url(#${this.ids.clip})`}
>
{text}
</text>
);
}
render(): React.Element<any> {
const className = classNames(styles.container, {
[styles.clickable]: this.props.onClick
}, this.props.className);
const size = this.getAvatarSize();
return (
<svg
viewBox="0 0 109 109"
width={size}
height={size}
className={className}
onClick={this.props.onClick}
>
<defs>
{this.renderDefsBig()}
{this.renderClipMaskBig()}
{this.renderDefsSmall()}
</defs>
{this.renderBigAvatar()}
{this.renderSmallAvatar()}
{this.renderPeerBigText()}
{this.renderPeerSmallText()}
</svg>
);
}
}
export default DoublePeerAvatar;
|
# This file describes the standard way to build Docker, using docker
# Usage:
# # Assemble the full dev environment. This is slow the first time.
# docker build -t docker .
# # Mount your source in an interactive container for quick testing:
# docker run -v `pwd`:/go/src/github.com/dotcloud/docker -privileged -i -t docker bash
# # Run the test suite:
# docker run -privileged docker hack/make.sh test
# # Publish a release:
# docker run -privileged \
# -e AWS_S3_BUCKET=baz \
# -e AWS_ACCESS_KEY=foo \
# -e AWS_SECRET_KEY=bar \
# -e GPG_PASSPHRASE=gloubiboulga \
# docker hack/release.sh
# Note: Apparmor used to mess with privileged mode, but this is no longer
# the case. Therefore, you don't have to disable it anymore.
docker-version 0.6.1
from ubuntu:12.04
maintainer Solomon Hykes <solomon@dotcloud.com>
# Build dependencies
run echo 'deb http://archive.ubuntu.com/ubuntu precise main universe' > /etc/apt/sources.list
run apt-get update
run apt-get install -y -q curl
run apt-get install -y -q git
run apt-get install -y -q mercurial
run apt-get install -y -q build-essential libsqlite3-dev
# Install Go
run curl -s https://go.googlecode.com/files/go1.2rc2.src.tar.gz | tar -v -C /usr/local -xz
env PATH /usr/local/go/bin:/usr/local/bin:/usr/local/sbin:/usr/bin:/usr/sbin:/bin:/sbin
env GOPATH /go:/go/src/github.com/dotcloud/docker/vendor
run cd /usr/local/go/src && ./make.bash && go install -ldflags '-w -linkmode external -extldflags "-static -Wl,--unresolved-symbols=<API key>"' -tags netgo -a std
# Ubuntu stuff
run apt-get install -y -q ruby1.9.3 rubygems libffi-dev
run gem install --no-rdoc --no-ri fpm
run apt-get install -y -q reprepro dpkg-sig
# Install s3cmd 1.0.1 (earlier versions don't support env variables in the config)
run apt-get install -y -q python-pip
run pip install s3cmd
run pip install python-magic
run /bin/echo -e '[default]\naccess_key=$AWS_ACCESS_KEY\nsecret_key=$AWS_SECRET_KEY\n' > /.s3cfg
# Runtime dependencies
run apt-get install -y -q iptables
run apt-get install -y -q lxc
run apt-get install -y -q aufs-tools
volume /var/lib/docker
workdir /go/src/github.com/dotcloud/docker
# Wrap all commands in the "docker-in-docker" script to allow nested containers
entrypoint ["hack/dind"]
# Upload docker source
add . /go/src/github.com/dotcloud/docker
|
#include "libxatmi.h"
int tpdiscon(int cd)
{
write(2, "tpdiscon not supported\n", 23);
tperrno = TPEPROTO;
return -1;
}
|
# ormbad.version
# Helper module for ORMBad version information
# Created: Thu Aug 13 12:38:42 2015 -0400
# ID: version.py [] benjamin@bengfort.com $
"""
Helper module for ORMBad version information.
"""
## Versioning
__version_info__ = {
'major': 0,
'minor': 1,
'micro': 0,
'releaselevel': 'final',
'serial': 0,
}
def get_version(short=False):
"""
Returns the version from the version info.
"""
assert __version_info__['releaselevel'] in ('alpha', 'beta', 'final')
vers = ["%(major)i.%(minor)i" % __version_info__, ]
if __version_info__['micro']:
vers.append(".%(micro)i" % __version_info__)
if __version_info__['releaselevel'] != 'final' and not short:
vers.append('%s%i' % (__version_info__['releaselevel'][0],
__version_info__['serial']))
return ''.join(vers)
|
var fs = require('fs');
var content = fs.read ('animeEpisode.json');
console.log(JSON.stringify(JSON.parse(content)[1][0].title));
videolinks=JSON.parse(content);
links=[];
function pages(k) {
var page = new WebPage();
page.open('http:
console.log('opened gogoanime :++++ ', status);
if (status==fail){
page.close();
pages(k);
}
if (status == success) {
page.includeJs('http://ajax.googleapis.com/ajax/libs/jquery/1.8.2/jquery.min.js', function () {
console.log('jq included')
var data = page.evaluate(function (data) {
var tempdata=[];
for (var i = 0; i <$('.post div:eq(1) table tbody tr td:eq(0) ul').length; i = i + 1) {
data.links.push($('.post div:eq(1) table tbody tr td:eq(0) ul li a').attr('href'));
}
return JSON.stringify(data);
});
links[k][m] = JSON.parse(data);
console.log(data);
if (m < links[k].length - 1) {
page.close();
console.log('next episoide called');
pages(k, m + 1);
}
;
if (m == links[k].length - 1) {
page.close();
console.log('next anime called');
var path = 'links.json';
fs.write(path, links[k], 'w');
pages(k + 1, 1);
}
if (k == links.length - 1) {
var path = 'links.json';
fs.write(path, links, 'w');
}
});
}
});
}
pages(1,1);
|
<!DOCTYPE HTML PUBLIC "-
<!-- NewPage -->
<html lang="en">
<head>
<!-- Generated by javadoc (version 1.7.0_67) on Fri Nov 14 18:25:20 PST 2014 -->
<meta http-equiv="Content-Type" content="text/html" charset="UTF-8">
<title>Uses of Class org.apache.hadoop.hbase.thrift.ThriftServerRunner (HBase 0.98.8-hadoop2 API)</title>
<meta name="date" content="2014-11-14">
<link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
</head>
<body>
<script type="text/javascript"><!
if (location.href.indexOf('is-external=true') == -1) {
parent.document.title="Uses of Class org.apache.hadoop.hbase.thrift.ThriftServerRunner (HBase 0.98.8-hadoop2 API)";
}
</script>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
<div class="topNav"><a name="navbar_top">
</a><a href="#skip-navbar_top" title="Skip navigation links"></a><a name="navbar_top_firstrow">
</a>
<ul class="navList" title="Navigation">
<li><a href="../../../../../../overview-summary.html">Overview</a></li>
<li><a href="../package-summary.html">Package</a></li>
<li><a href="../../../../../../org/apache/hadoop/hbase/thrift/ThriftServerRunner.html" title="class in org.apache.hadoop.hbase.thrift">Class</a></li>
<li class="navBarCell1Rev">Use</li>
<li><a href="../package-tree.html">Tree</a></li>
<li><a href="../../../../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../../../../index-all.html">Index</a></li>
<li><a href="../../../../../../help-doc.html">Help</a></li>
</ul>
</div>
<div class="subNav">
<ul class="navList">
<li>Prev</li>
<li>Next</li>
</ul>
<ul class="navList">
<li><a href="../../../../../../index.html?org/apache/hadoop/hbase/thrift/class-use/ThriftServerRunner.html" target="_top">Frames</a></li>
<li><a href="ThriftServerRunner.html" target="_top">No Frames</a></li>
</ul>
<ul class="navList" id="<API key>">
<li><a href="../../../../../../allclasses-noframe.html">All Classes</a></li>
</ul>
<div>
<script type="text/javascript"><!
allClassesLink = document.getElementById("<API key>");
if(window==top) {
allClassesLink.style.display = "block";
}
else {
allClassesLink.style.display = "none";
}
</script>
</div>
<a name="skip-navbar_top">
</a></div>
<div class="header">
<h2 title="Uses of Class org.apache.hadoop.hbase.thrift.ThriftServerRunner" class="title">Uses of Class<br>org.apache.hadoop.hbase.thrift.ThriftServerRunner</h2>
</div>
<div class="classUseContainer">No usage of org.apache.hadoop.hbase.thrift.ThriftServerRunner</div>
<div class="bottomNav"><a name="navbar_bottom">
</a><a href="#skip-navbar_bottom" title="Skip navigation links"></a><a name="<API key>">
</a>
<ul class="navList" title="Navigation">
<li><a href="../../../../../../overview-summary.html">Overview</a></li>
<li><a href="../package-summary.html">Package</a></li>
<li><a href="../../../../../../org/apache/hadoop/hbase/thrift/ThriftServerRunner.html" title="class in org.apache.hadoop.hbase.thrift">Class</a></li>
<li class="navBarCell1Rev">Use</li>
<li><a href="../package-tree.html">Tree</a></li>
<li><a href="../../../../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../../../../index-all.html">Index</a></li>
<li><a href="../../../../../../help-doc.html">Help</a></li>
</ul>
</div>
<div class="subNav">
<ul class="navList">
<li>Prev</li>
<li>Next</li>
</ul>
<ul class="navList">
<li><a href="../../../../../../index.html?org/apache/hadoop/hbase/thrift/class-use/ThriftServerRunner.html" target="_top">Frames</a></li>
<li><a href="ThriftServerRunner.html" target="_top">No Frames</a></li>
</ul>
<ul class="navList" id="<API key>">
<li><a href="../../../../../../allclasses-noframe.html">All Classes</a></li>
</ul>
<div>
<script type="text/javascript"><!
allClassesLink = document.getElementById("<API key>");
if(window==top) {
allClassesLink.style.display = "block";
}
else {
allClassesLink.style.display = "none";
}
</script>
</div>
<a name="skip-navbar_bottom">
</a></div>
<p class="legalCopy"><small>Copyright &
</body>
</html>
|
/* "C" Language Integrated Production System */
/* CLIPS Version 6.20 01/31/02 */
/* DEFFACTS PARSER HEADER FILE */
/* Purpose: */
/* Principal Programmer(s): */
/* Gary D. Riley */
/* Contributing Programmer(s): */
/* Brian L. Donnell */
/* Revision History: */
#ifndef _H_dffctpsr
#define _H_dffctpsr
#ifdef LOCALE
#undef LOCALE
#endif
#ifdef _DFFCTPSR_SOURCE_
#define LOCALE
#else
#define LOCALE extern
#endif
LOCALE int ParseDeffacts(void *,char *);
#endif
|
package org.cluj.bus.servlet;
import com.google.gson.Gson;
import org.cluj.bus.model.BusSchedule;
import org.cluj.bus.model.BusScheduleDTO;
import org.cluj.bus.model.CategorySchedule;
import org.cluj.bus.services.JPARepository;
import org.cluj.bus.util.ScheduleUtilities;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.text.ParseException;
import java.util.*;
import java.util.logging.Level;
import java.util.logging.Logger;
public class BusScheduleServlet extends HttpServlet
{
private static final Logger LOGGER = Logger.getLogger(BusScheduleServlet.class.getName());
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException
{
doPost(req, resp);
}
@Override
protected void doPost(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws ServletException, IOException
{
String busId = httpServletRequest.getParameter(ServletUtils.<API key>);
ServletUtils.sendResponse(httpServletResponse, getResponseString(busId));
}
private String getResponseString(String busId)
{
List<BusSchedule> busSchedules = new JPARepository<>(BusSchedule.class).findAll("busId", busId);
Map<String, CategorySchedule> categorySchedules = new HashMap<>();
for (BusSchedule busSchedule : busSchedules)
{
String days = busSchedule.getDays();
CategorySchedule categorySchedule = categorySchedules.get(days);
if (categorySchedule == null)
{
categorySchedule = new CategorySchedule();
categorySchedules.put(days, categorySchedule);
categorySchedule.setDisplayName(busSchedule.getCategory());
categorySchedule.setApplicableDays(getApplicableDays(days));
}
Collection<Date> startTimes = categorySchedule.getStartTimes();
if (startTimes == null)
{
startTimes = new ArrayList<>();
categorySchedule.setStartTimes(startTimes);
}
try
{
startTimes.add(ScheduleUtilities.getStartTime(busSchedule.getStartTime()));
}
catch (ParseException e)
{
LOGGER.log(Level.SEVERE, "Error parsing start time", e);
}
}
BusScheduleDTO schedule = new BusScheduleDTO();
schedule.setSchedules(categorySchedules.values());
return new Gson().toJson(schedule);
}
private Collection<Integer> getApplicableDays(String days)
{
List<Integer> applicableDays = new ArrayList<>();
for (char aChar : days.toCharArray())
{
int day = Integer.parseInt(String.valueOf(aChar));
applicableDays.add(day);
}
return applicableDays;
}
}
|
<!DOCTYPE HTML PUBLIC "-
<html>
<head>
<meta httpEquiv="Content-Type" content="text/html; charset=utf-8"/>
<title>Test results - Class carlosgsouza.vinylshop.functional.v1.<API key></title>
<link href="base-style.css" rel="stylesheet" type="text/css"/>
<link href="style.css" rel="stylesheet" type="text/css"/>
<script src="report.js" type="text/javascript"></script>
</head>
<body>
<div id="content">
<h1>Class carlosgsouza.vinylshop.functional.v1.<API key></h1>
<div class="breadcrumbs">
<a href="index.html">all</a> >
<a href="carlosgsouza.vinylshop.functional.v1.html">carlosgsouza.vinylshop.functional.v1</a> > <API key></div>
<div id="summary">
<table>
<tr>
<td>
<div class="summaryGroup">
<table>
<tr>
<td>
<div class="infoBox" id="tests">
<div class="counter">1</div>
<p>tests</p>
</div>
</td>
<td>
<div class="infoBox" id="failures">
<div class="counter">0</div>
<p>failures</p>
</div>
</td>
<td>
<div class="infoBox" id="duration">
<div class="counter">0.054s</div>
<p>duration</p>
</div>
</td>
</tr>
</table>
</div>
</td>
<td>
<div class="infoBox success" id="successRate">
<div class="percent">100%</div>
<p>successful</p>
</div>
</td>
</tr>
</table>
</div>
<div id="tabs">
<ul class="tabLinks">
<li>
<a href="#tab0">Tests</a>
</li>
</ul>
<div id="tab0" class="tab">
<h2>Tests</h2>
<table>
<thead>
<tr>
<th>Test</th>
<th>Duration</th>
<th>Result</th>
</tr>
</thead>
<tr>
<td class="success">should show a summary of the vinyls</td>
<td>0.054s</td>
<td class="success">passed</td>
</tr>
</table>
</div>
</div>
<div id="footer">
<p>Generated by
<a href="http:
</div>
</div>
</body>
|
using System;
using System.Collections.Immutable;
using System.Composition;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.CodeAnalysis.Completion;
using Microsoft.CodeAnalysis.Completion.Providers;
using Microsoft.CodeAnalysis.CSharp.Completion.KeywordRecommenders;
using Microsoft.CodeAnalysis.CSharp.Extensions.ContextQuery;
using Microsoft.CodeAnalysis.Host.Mef;
using Microsoft.CodeAnalysis.Options;
using Microsoft.CodeAnalysis.Shared.Extensions;
using Microsoft.CodeAnalysis.Text;
namespace Microsoft.CodeAnalysis.CSharp.Completion.Providers
{
[<API key>(nameof(<API key>), LanguageNames.CSharp)]
[ExtensionOrder(After = nameof(<API key>))]
[Shared]
internal class <API key> : <API key><CSharpSyntaxContext>
{
[<API key>]
[Obsolete(MefConstruction.<API key>, error: true)]
public <API key>()
: base(<API key>())
{
}
private static ImmutableArray<IKeywordRecommender<CSharpSyntaxContext>> <API key>()
{
return new IKeywordRecommender<CSharpSyntaxContext>[]
{
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
new <API key>(),
}.ToImmutableArray();
}
internal override bool IsInsertionTrigger(SourceText text, int characterPosition, OptionSet options)
=> CompletionUtilities.IsTriggerCharacter(text, characterPosition, options);
internal override ImmutableHashSet<char> TriggerCharacters { get; } = CompletionUtilities.<API key>;
protected override async Task<CSharpSyntaxContext> CreateContextAsync(Document document, int position, Cancellation<API key>)
{
var span = new TextSpan(position, length: 0);
var semanticModel = await document.<API key>(span, cancellationToken).ConfigureAwait(false);
return CSharpSyntaxContext.CreateContext(document.Project.Solution.Workspace, semanticModel, position, cancellationToken);
}
private static readonly CompletionItemRules s_tupleRules = CompletionItemRules.Default.
<API key>(<API key>.Create(<API key>.Remove, ':'));
protected override CompletionItem CreateItem(RecommendedKeyword keyword, CSharpSyntaxContext context)
{
var rules = context.<API key> ? s_tupleRules : CompletionItemRules.Default;
return <API key>.Create(
displayText: keyword.Keyword,
displayTextSuffix: "",
description: keyword.DescriptionFactory(CancellationToken.None),
glyph: Glyph.Keyword,
rules: rules.WithMatchPriority(keyword.MatchPriority)
.WithFormatOnCommit(keyword.<API key>));
}
internal override TextSpan GetCurrentSpan(TextSpan span, SourceText text)
=> CompletionUtilities.<API key>(text, span.End);
}
}
|
package com.wjyup.coolq.util;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.google.common.hash.HashCode;
import com.google.common.hash.HashFunction;
import com.google.common.hash.Hashing;
import com.google.gson.JsonObject;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.util.DigestUtils;
import java.nio.charset.StandardCharsets;
/**
*
* @author WJY
*/
public class SendMessageUtil {
private static Logger log = LogManager.getLogger(SendMessageUtil.class);
/**
* json
* @param message
* @return
*/
public static String sendSocketData(String message){
try {
ConfigCache configCache = SpringContext.getConfigCache();
if(StaticConf.MSG_SEND_TYPE_HTTP.equalsIgnoreCase(configCache.getMSG_SEND_TYPE())){// http
String url = String.format("http://%s:%s", configCache.getHTTP_HOST(), configCache.getHTTP_PORT());
if(configCache.isUSE_TOKEN()){// token
long authTime = System.currentTimeMillis() / 1000;
String key = configCache.getKEY()+":"+authTime;
String authToken = DigestUtils.md5DigestAsHex(key.getBytes(StandardCharsets.UTF_8));
JSONObject jsonObject = JSON.parseObject(message);
jsonObject.put("authTime", authTime);
jsonObject.put("authToken", authToken);
message = jsonObject.toJSONString();
}
log.debug("json"+message);
try{
String result = WebUtil.post(url, message);
log.debug(":" + result);
return result;
}catch (Exception e){
log.error(e.getMessage(),e);
}
}
} catch (Exception e) {
log.error(e.getMessage(), e);
}
return null;
}
}
|
<!DOCTYPE HTML PUBLIC "-
<!-- NewPage -->
<html lang="en">
<head>
<!-- Generated by javadoc (1.8.0_222) on Thu Jan 16 21:49:29 PST 2020 -->
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Uses of Class org.apache.datasketches.quantiles.DoublesUnionBuilder (datasketches-java 1.2.0-incubating API)</title>
<meta name="date" content="2020-01-16">
<link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
<script type="text/javascript" src="../../../../../script.js"></script>
</head>
<body>
<script type="text/javascript"><!
try {
if (location.href.indexOf('is-external=true') == -1) {
parent.document.title="Uses of Class org.apache.datasketches.quantiles.DoublesUnionBuilder (datasketches-java 1.2.0-incubating API)";
}
}
catch(err) {
}
</script>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
<div class="topNav"><a name="navbar.top">
</a>
<div class="skipNav"><a href="#skip.navbar.top" title="Skip navigation links">Skip navigation links</a></div>
<a name="navbar.top.firstrow">
</a>
<ul class="navList" title="Navigation">
<li><a href="../../../../../overview-summary.html">Overview</a></li>
<li><a href="../package-summary.html">Package</a></li>
<li><a href="../../../../../org/apache/datasketches/quantiles/DoublesUnionBuilder.html" title="class in org.apache.datasketches.quantiles">Class</a></li>
<li class="navBarCell1Rev">Use</li>
<li><a href="../package-tree.html">Tree</a></li>
<li><a href="../../../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../../../index-all.html">Index</a></li>
<li><a href="../../../../../help-doc.html">Help</a></li>
</ul>
</div>
<div class="subNav">
<ul class="navList">
<li>Prev</li>
<li>Next</li>
</ul>
<ul class="navList">
<li><a href="../../../../../index.html?org/apache/datasketches/quantiles/class-use/DoublesUnionBuilder.html" target="_top">Frames</a></li>
<li><a href="DoublesUnionBuilder.html" target="_top">No Frames</a></li>
</ul>
<ul class="navList" id="<API key>">
<li><a href="../../../../../allclasses-noframe.html">All Classes</a></li>
</ul>
<div>
<script type="text/javascript"><!
allClassesLink = document.getElementById("<API key>");
if(window==top) {
allClassesLink.style.display = "block";
}
else {
allClassesLink.style.display = "none";
}
</script>
</div>
<a name="skip.navbar.top">
</a></div>
<div class="header">
<h2 title="Uses of Class org.apache.datasketches.quantiles.DoublesUnionBuilder" class="title">Uses of Class<br>org.apache.datasketches.quantiles.DoublesUnionBuilder</h2>
</div>
<div class="classUseContainer">
<ul class="blockList">
<li class="blockList">
<table class="useSummary" border="0" cellpadding="3" cellspacing="0" summary="Use table, listing packages, and an explanation">
<caption><span>Packages that use <a href="../../../../../org/apache/datasketches/quantiles/DoublesUnionBuilder.html" title="class in org.apache.datasketches.quantiles">DoublesUnionBuilder</a></span><span class="tabEnd"> </span></caption>
<tr>
<th class="colFirst" scope="col">Package</th>
<th class="colLast" scope="col">Description</th>
</tr>
<tbody>
<tr class="altColor">
<td class="colFirst"><a href="#org.apache.datasketches.quantiles">org.apache.datasketches.quantiles</a></td>
<td class="colLast">
<div class="block">The quantiles package contains stochastic streaming algorithms that enable single-pass
analysis of the distribution of a stream of real (double) values or generic items.</div>
</td>
</tr>
</tbody>
</table>
</li>
<li class="blockList">
<ul class="blockList">
<li class="blockList"><a name="org.apache.datasketches.quantiles">
</a>
<h3>Uses of <a href="../../../../../org/apache/datasketches/quantiles/DoublesUnionBuilder.html" title="class in org.apache.datasketches.quantiles">DoublesUnionBuilder</a> in <a href="../../../../../org/apache/datasketches/quantiles/package-summary.html">org.apache.datasketches.quantiles</a></h3>
<table class="useSummary" border="0" cellpadding="3" cellspacing="0" summary="Use table, listing methods, and an explanation">
<caption><span>Methods in <a href="../../../../../org/apache/datasketches/quantiles/package-summary.html">org.apache.datasketches.quantiles</a> that return <a href="../../../../../org/apache/datasketches/quantiles/DoublesUnionBuilder.html" title="class in org.apache.datasketches.quantiles">DoublesUnionBuilder</a></span><span class="tabEnd"> </span></caption>
<tr>
<th class="colFirst" scope="col">Modifier and Type</th>
<th class="colLast" scope="col">Method and Description</th>
</tr>
<tbody>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../../org/apache/datasketches/quantiles/DoublesUnionBuilder.html" title="class in org.apache.datasketches.quantiles">DoublesUnionBuilder</a></code></td>
<td class="colLast"><span class="typeNameLabel">DoublesUnion.</span><code><span class="memberNameLink"><a href="../../../../../org/apache/datasketches/quantiles/DoublesUnion.html#builder--">builder</a></span>()</code>
<div class="block">Returns a new UnionBuilder</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code><a href="../../../../../org/apache/datasketches/quantiles/DoublesUnionBuilder.html" title="class in org.apache.datasketches.quantiles">DoublesUnionBuilder</a></code></td>
<td class="colLast"><span class="typeNameLabel">DoublesUnionBuilder.</span><code><span class="memberNameLink"><a href="../../../../../org/apache/datasketches/quantiles/DoublesUnionBuilder.html#setMaxK-int-">setMaxK</a></span>(int maxK)</code>
<div class="block">Sets the parameter <i>masK</i> that determines the maximum size of the sketch that
results from a union and its accuracy.</div>
</td>
</tr>
</tbody>
</table>
</li>
</ul>
</li>
</ul>
</div>
<div class="bottomNav"><a name="navbar.bottom">
</a>
<div class="skipNav"><a href="#skip.navbar.bottom" title="Skip navigation links">Skip navigation links</a></div>
<a name="navbar.bottom.firstrow">
</a>
<ul class="navList" title="Navigation">
<li><a href="../../../../../overview-summary.html">Overview</a></li>
<li><a href="../package-summary.html">Package</a></li>
<li><a href="../../../../../org/apache/datasketches/quantiles/DoublesUnionBuilder.html" title="class in org.apache.datasketches.quantiles">Class</a></li>
<li class="navBarCell1Rev">Use</li>
<li><a href="../package-tree.html">Tree</a></li>
<li><a href="../../../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../../../index-all.html">Index</a></li>
<li><a href="../../../../../help-doc.html">Help</a></li>
</ul>
</div>
<div class="subNav">
<ul class="navList">
<li>Prev</li>
<li>Next</li>
</ul>
<ul class="navList">
<li><a href="../../../../../index.html?org/apache/datasketches/quantiles/class-use/DoublesUnionBuilder.html" target="_top">Frames</a></li>
<li><a href="DoublesUnionBuilder.html" target="_top">No Frames</a></li>
</ul>
<ul class="navList" id="<API key>">
<li><a href="../../../../../allclasses-noframe.html">All Classes</a></li>
</ul>
<div>
<script type="text/javascript"><!
allClassesLink = document.getElementById("<API key>");
if(window==top) {
allClassesLink.style.display = "block";
}
else {
allClassesLink.style.display = "none";
}
</script>
</div>
<a name="skip.navbar.bottom">
</a></div>
<p class="legalCopy"><small>Copyright &
</body>
</html>
|
# vim: set et sw=4 sts=4 fileencoding=utf-8:
# Python header conversion
# Original headers
# modification, are permitted provided that the following conditions are met:
# documentation and/or other materials provided with the distribution.
# names of its contributors may be used to endorse or promote products
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
from __future__ import (
unicode_literals,
print_function,
division,
absolute_import,
)
# Make Py2's str equivalent to Py3's
str = type('')
import ctypes as ct
import warnings
_lib = ct.CDLL('libbcm_host.so')
bcm_host_init = _lib.bcm_host_init
bcm_host_init.argtypes = []
bcm_host_init.restype = None
bcm_host_deinit = _lib.bcm_host_deinit
bcm_host_deinit.argtypes = []
bcm_host_deinit.restype = None
<API key> = _lib.<API key>
<API key>.argtypes = [ct.c_uint16, ct.POINTER(ct.c_uint32), ct.POINTER(ct.c_uint32)]
<API key>.restype = ct.c_int32
|
# quick demo of some python image filters
# using raspberry pi camera
import Tkinter as tk
from picamera import PiCamera
from time import sleep
from PIL import Image,ImageFilter,ImageChops,ImageTk
imagefile = "image.jpg"
w = 320
h = 240
lastfilter = "none"
camera = PiCamera()
def takephoto():
camera.capture(imagefile)
image1 = Image.open(imagefile)
return image1
def photoloop():
count = 0
while (count < 9):
sleep(0.5)
image1 = newphoto()
if lastfilter is not "none":
dofilter(lastfilter,image1)
count = count + 1
def newphoto():
global image1
image1 = takephoto()
tkimage1 = ImageTk.PhotoImage(image1)
panel1.configure(image=tkimage1)
panel1.image = tkimage1
def invert():
global image1
image1= ImageChops.invert(image1)
tkimage1 = ImageTk.PhotoImage(image1)
panel1.configure(image=tkimage1)
panel1.image = tkimage1
def grayscale():
global image1
r, g, b = image1.split()
image1 = Image.merge("RGB", (g,g,g))
tkimage1 = ImageTk.PhotoImage(image1)
panel1.configure(image=tkimage1)
panel1.image = tkimage1
def dofilter (theimage,thefilter):
lastfilter = thefilter
global image1
image1 = image1.filter(thefilter)
tkimage1 = ImageTk.PhotoImage(image1)
panel1.configure(image=tkimage1)
panel1.image = tkimage1
# Setup a window
root = tk.Tk()
root.title('Image')
image1 = takephoto()
tkimage1 = ImageTk.PhotoImage(image1)
w = tkimage1.width()
h = tkimage1.height()
root.geometry("%dx%d+%d+%d" % (w, h, 0, 0))
# root has no image argument, so use a label as a panel
panel1 = tk.Label(root, image=tkimage1)
panel1.pack(side='top', fill='both', expand='yes')
# save the panel's image from 'garbage collection'
panel1.image = tkimage1
# Add some buttons
buttonrow = tk.Frame(root)
buttonrow.place(y=0,x=0)
button = tk.Button(buttonrow, text='CAMERA',command = lambda: newphoto())
button.pack(side='left',)
button = tk.Button(buttonrow, text='LOOP',command = lambda: photoloop())
button.pack(side='left',)
button = tk.Button(buttonrow, text='INVERT',command = lambda: invert())
button.pack(side='left',)
button = tk.Button(buttonrow, text='GRAY',command = lambda: grayscale())
button.pack(side='left',)
# add some filter buttons
button = tk.Button(buttonrow, text='BLUR',command = lambda: dofilter(image1,ImageFilter.BLUR))
button.pack(side='left')
button = tk.Button(buttonrow, text='CONTOUR',command = lambda: dofilter(image1,ImageFilter.CONTOUR))
button.pack(side='left')
button = tk.Button(buttonrow, text='FIND_EDGES',command = lambda: dofilter(image1,ImageFilter.FIND_EDGES))
button.pack(side='left')
button = tk.Button(buttonrow, text='EMBOSS',command = lambda: dofilter(image1,ImageFilter.EMBOSS))
button.pack(side='left')
button = tk.Button(buttonrow, text='EDGE_ENHANCE',command = lambda: dofilter(image1,ImageFilter.EDGE_ENHANCE))
button.pack(side='left')
button = tk.Button(buttonrow, text='CLOSE',command = lambda: root.destroy())
button.pack(side='left')
root.mainloop()
|
var a02307 =
[
[ "GenericVector", "a02307.html#<API key>", null ],
[ "GenericVector", "a02307.html#<API key>", null ],
[ "GenericVector", "a02307.html#<API key>", null ],
[ "~GenericVector", "a02307.html#<API key>", null ],
[ "back", "a02307.html#<API key>", null ],
[ "binary_search", "a02307.html#<API key>", null ],
[ "bool_binary_search", "a02307.html#<API key>", null ],
[ "choose_nth_item", "a02307.html#<API key>", null ],
[ "choose_nth_item", "a02307.html#<API key>", null ],
[ "clear", "a02307.html#<API key>", null ],
[ "compact", "a02307.html#<API key>", null ],
[ "compact_sorted", "a02307.html#<API key>", null ],
[ "contains", "a02307.html#<API key>", null ],
[ "contains_index", "a02307.html#<API key>", null ],
[ "<API key>", "a02307.html#<API key>", null ],
[ "DeSerialize", "a02307.html#<API key>", null ],
[ "DeSerialize", "a02307.html#<API key>", null ],
[ "DeSerializeClasses", "a02307.html#<API key>", null ],
[ "DeSerializeClasses", "a02307.html#<API key>", null ],
[ "dot_product", "a02307.html#<API key>", null ],
[ "double_the_size", "a02307.html#<API key>", null ],
[ "empty", "a02307.html#<API key>", null ],
[ "get", "a02307.html#<API key>", null ],
[ "get_index", "a02307.html#<API key>", null ],
[ "init", "a02307.html#<API key>", null ],
[ "init_to_size", "a02307.html#<API key>", null ],
[ "insert", "a02307.html#<API key>", null ],
[ "length", "a02307.html#<API key>", null ],
[ "move", "a02307.html#<API key>", null ],
[ "operator+=", "a02307.html#<API key>", null ],
[ "operator+=", "a02307.html#<API key>", null ],
[ "operator=", "a02307.html#<API key>", null ],
[ "operator[]", "a02307.html#<API key>", null ],
[ "pop_back", "a02307.html#<API key>", null ],
[ "push_back", "a02307.html#<API key>", null ],
[ "push_back_new", "a02307.html#<API key>", null ],
[ "push_front", "a02307.html#<API key>", null ],
[ "read", "a02307.html#<API key>", null ],
[ "remove", "a02307.html#<API key>", null ],
[ "reserve", "a02307.html#<API key>", null ],
[ "resize_no_init", "a02307.html#<API key>", null ],
[ "reverse", "a02307.html#<API key>", null ],
[ "Serialize", "a02307.html#<API key>", null ],
[ "Serialize", "a02307.html#<API key>", null ],
[ "SerializeClasses", "a02307.html#<API key>", null ],
[ "SerializeClasses", "a02307.html#<API key>", null ],
[ "set", "a02307.html#<API key>", null ],
[ "set_clear_callback", "a02307.html#<API key>", null ],
[ "<API key>", "a02307.html#<API key>", null ],
[ "size", "a02307.html#<API key>", null ],
[ "size_reserved", "a02307.html#<API key>", null ],
[ "sort", "a02307.html#<API key>", null ],
[ "sort", "a02307.html#<API key>", null ],
[ "swap", "a02307.html#<API key>", null ],
[ "truncate", "a02307.html#<API key>", null ],
[ "unsigned_size", "a02307.html#<API key>", null ],
[ "WithinBounds", "a02307.html#<API key>", null ],
[ "write", "a02307.html#<API key>", null ],
[ "clear_cb_", "a02307.html#<API key>", null ],
[ "compare_cb_", "a02307.html#<API key>", null ],
[ "data_", "a02307.html#<API key>", null ],
[ "size_reserved_", "a02307.html#<API key>", null ],
[ "size_used_", "a02307.html#<API key>", null ]
];
|
note
* this is a resuable container for a given project/volume
initial steps
* ensure current directory contains `resources/jdk-9+175_linux-x64_bin.tar.gz`
* run: `docker build -t="jdk9/b175" .`
* run: `docker run -i -t -v $(pwd):/data jdk9/b175`
* inside container, run: `/data/resources/install.sh`
* inside container, run: `. /data/resources/setvars.sh`
* confirm: `java --version`
subsequent steps
* `docker start [container name]`
* `docker attach [container name]`
* run: `. /data/resources/setvars.sh`
* confirm: `java --version`
|
package template
import (
"bytes"
"io"
"io/ioutil"
"log"
"os"
"testing"
"text/template"
"github.com/k8sp/sextant/cloud-config-server/certgen"
"github.com/k8sp/sextant/clusterdesc"
"github.com/stretchr/testify/assert"
"github.com/topicai/candy"
"gopkg.in/yaml.v2"
)
func TestExecute(t *testing.T) {
out, err := ioutil.TempDir("", "")
candy.Must(err)
defer func() {
if e := os.RemoveAll(out); e != nil {
log.Printf("Generator.Gen failed deleting %s", out)
}
}()
caKey, caCrt := certgen.GenerateRootCA(out)
config := candy.WithOpened("./cluster-desc.sample.yaml", func(r io.Reader) interface{} {
b, e := ioutil.ReadAll(r)
candy.Must(e)
c := &clusterdesc.Cluster{}
assert.Nil(t, yaml.Unmarshal(b, &c))
return c
}).(*clusterdesc.Cluster)
tmpl, e := template.ParseFiles("cloud-config.template")
candy.Must(e)
var ccTmpl bytes.Buffer
Execute(tmpl, config, "00:25:90:c0:f7:80", caKey, caCrt, &ccTmpl)
yml := make(map[interface{}]interface{})
candy.Must(yaml.Unmarshal(ccTmpl.Bytes(), yml))
initialEtcdCluster := yml["coreos"].(map[interface{}]interface{})["etcd2"].(map[interface{}]interface{})["<API key>"]
assert.Equal(t, initialEtcdCluster, "etcd-cluster-1")
}
|
package mx.emite.sdk.scot.request;
import java.util.List;
import javax.validation.Valid;
import javax.validation.constraints.NotNull;
import org.hibernate.validator.constraints.NotEmpty;
import lombok.Builder;
import lombok.Data;
import lombok.Singular;
import mx.emite.sdk.cfdi32.anotaciones.Rfc;
import mx.emite.sdk.scot.request.extra.SucursalInfo;
@Data
@Builder
public class <API key> {
/**
* Token del <b>Integrador</b> obtenido con el servicio de Token
* -- SETTER --
*
* @param token
* Token del <b>Integrador</b> obtenido de Scot©
*
*/
@NotNull
private String token;
/**
* @param rfc del emisor, si se deja en blanco se consultan todos los emisores
*/
@Rfc
private String rfc;
/**
* @param sucursales lista de sucursales a dar de alta
*/
@Valid @NotEmpty @Singular("sucursal")
private List<SucursalInfo> sucursales;
/**
* modificar si la sucursal ya se encuentra dado de alta
*/
@NotNull
public Boolean modificar;
}
|
#include "bme680.h"
#include <gpio.h>
#include <i2c.h>
#include <init.h>
#include <kernel.h>
#include <misc/byteorder.h>
#include <misc/__assert.h>
#include <sensor.h>
#include <logging/log.h>
LOG_MODULE_REGISTER(bme680, <API key>);
static int bme680_reg_read(struct bme680_data *data, u8_t start, u8_t *buf,
int size)
{
return i2c_burst_read(data->i2c_master, data->i2c_slave_addr, start,
buf, size);
return 0;
}
static int bme680_reg_write(struct bme680_data *data, u8_t reg, u8_t val)
{
return i2c_reg_write_byte(data->i2c_master, data->i2c_slave_addr,
reg, val);
return 0;
}
static void bme680_calc_temp(struct bme680_data *data, u32_t adc_temp)
{
s64_t var1, var2, var3;
var1 = ((s32_t)adc_temp >> 3) - ((s32_t)data->par_t1 << 1);
var2 = (var1 * (s32_t)data->par_t2) >> 11;
var3 = ((var1 >> 1) * (var1 >> 1)) >> 12;
var3 = ((var3) * ((s32_t)data->par_t3 << 4)) >> 14;
data->t_fine = var2 + var3;
data->calc_temp = ((data->t_fine * 5) + 128) >> 8;
}
static void bme680_calc_press(struct bme680_data *data, u32_t adc_press)
{
s32_t var1, var2, var3, calc_press;
var1 = (((s32_t)data->t_fine) >> 1) - 64000;
var2 = ((((var1 >> 2) * (var1 >> 2)) >> 11) *
(s32_t)data->par_p6) >> 2;
var2 = var2 + ((var1 * (s32_t)data->par_p5) << 1);
var2 = (var2 >> 2) + ((s32_t)data->par_p4 << 16);
var1 = (((((var1 >> 2) * (var1 >> 2)) >> 13) *
((s32_t)data->par_p3 << 5)) >> 3)
+ (((s32_t)data->par_p2 * var1) >> 1);
var1 = var1 >> 18;
var1 = ((32768 + var1) * (s32_t)data->par_p1) >> 15;
calc_press = 1048576 - adc_press;
calc_press = (calc_press - (var2 >> 12)) * ((u32_t)3125);
/* This max value is used to provide precedence to multiplication or
* division in the pressure calculation equation to achieve least
* loss of precision and avoiding overflows.
* i.e Comparing value, signed int 32bit (1 << 30)
*/
if (calc_press >= (s32_t)0x40000000) {
calc_press = ((calc_press / var1) << 1);
} else {
calc_press = ((calc_press << 1) / var1);
}
var1 = ((s32_t)data->par_p9 *
(s32_t)(((calc_press >> 3)
* (calc_press >> 3)) >> 13)) >> 12;
var2 = ((s32_t)(calc_press >> 2) * (s32_t)data->par_p8) >> 13;
var3 = ((s32_t)(calc_press >> 8) * (s32_t)(calc_press >> 8)
* (s32_t)(calc_press >> 8)
* (s32_t)data->par_p10) >> 17;
data->calc_press = calc_press
+ ((var1 + var2 + var3
+ ((s32_t)data->par_p7 << 7)) >> 4);
}
static void <API key>(struct bme680_data *data, u16_t adc_humidity)
{
s32_t var1, var2_1, var2_2, var2, var3, var4, var5, var6;
s32_t temp_scaled, calc_hum;
temp_scaled = (((s32_t)data->t_fine * 5) + 128) >> 8;
var1 = (s32_t)(adc_humidity - ((s32_t)((s32_t)data->par_h1 * 16))) -
(((temp_scaled * (s32_t)data->par_h3)
/ ((s32_t)100)) >> 1);
var2_1 = (s32_t)data->par_h2;
var2_2 = ((temp_scaled * (s32_t)data->par_h4) / (s32_t)100)
+ (((temp_scaled * ((temp_scaled * (s32_t)data->par_h5)
/ ((s32_t)100))) >> 6) / ((s32_t)100))
+ (s32_t)(1 << 14);
var2 = (var2_1 * var2_2) >> 10;
var3 = var1 * var2;
var4 = (s32_t)data->par_h6 << 7;
var4 = ((var4) + ((temp_scaled * (s32_t)data->par_h7) /
((s32_t)100))) >> 4;
var5 = ((var3 >> 14) * (var3 >> 14)) >> 10;
var6 = (var4 * var5) >> 1;
calc_hum = (((var3 + var6) >> 10) * ((s32_t)1000)) >> 12;
if (calc_hum > 100000) { /* Cap at 100%rH */
calc_hum = 100000;
} else if (calc_hum < 0) {
calc_hum = 0;
}
data->calc_humidity = calc_hum;
}
static void <API key>(struct bme680_data *data, u8_t gas_range,
u16_t adc_gas_res)
{
s64_t var1, var3;
u64_t var2;
static const u32_t look_up1[16] = { 2147483647, 2147483647, 2147483647,
2147483647, 2147483647, 2126008810, 2147483647,
2130303777, 2147483647, 2147483647, 2143188679,
2136746228, 2147483647, 2126008810, 2147483647,
2147483647 };
static const u32_t look_up2[16] = { 4096000000, 2048000000, 1024000000,
512000000, 255744255, 127110228, 64000000,
32258064, 16016016, 8000000, 4000000, 2000000,
1000000, 500000, 250000, 125000 };
var1 = (s64_t)((1340 + (5 * (s64_t)data->range_sw_err)) *
((s64_t)look_up1[gas_range])) >> 16;
var2 = (((s64_t)((s64_t)adc_gas_res << 15) - (s64_t)(16777216)) + var1);
var3 = (((s64_t)look_up2[gas_range] * (s64_t)var1) >> 9);
data->calc_gas_resistance = (u32_t)((var3 + ((s64_t)var2 >> 1))
/ (s64_t)var2);
}
static u8_t <API key>(struct bme680_data *data, u16_t heatr_temp)
{
u8_t heatr_res;
s32_t var1, var2, var3, var4, var5;
s32_t heatr_res_x100;
s32_t amb_temp = 25; /* Assume ambient temperature to be 25 deg C */
if (heatr_temp > 400) { /* Cap temperature */
heatr_temp = 400;
}
var1 = ((amb_temp * data->par_gh3) / 1000) * 256;
var2 = (data->par_gh1 + 784) * (((((data->par_gh2 + 154009)
* heatr_temp * 5) / 100)
+ 3276800) / 10);
var3 = var1 + (var2 / 2);
var4 = (var3 / (data->res_heat_range + 4));
var5 = (131 * data->res_heat_val) + 65536;
heatr_res_x100 = ((var4 / var5) - 250) * 34;
heatr_res = (heatr_res_x100 + 50) / 100;
return heatr_res;
}
static u8_t <API key>(u16_t dur)
{
u8_t factor = 0, durval;
if (dur >= 0xfc0) {
durval = 0xff; /* Max duration*/
} else {
while (dur > 0x3F) {
dur = dur / 4;
factor += 1;
}
durval = dur + (factor * 64);
}
return durval;
}
static int bme680_sample_fetch(struct device *dev, enum sensor_channel chan)
{
struct bme680_data *data = dev->driver_data;
u8_t buff[BME680_LEN_FIELD] = { 0 };
u8_t gas_range;
u32_t adc_temp, adc_press;
u16_t adc_hum, adc_gas_res;
int size = BME680_LEN_FIELD;
int ret;
__ASSERT_NO_MSG(chan == SENSOR_CHAN_ALL);
ret = bme680_reg_read(data, BME680_REG_FIELD0, buff, size);
if (ret < 0) {
return ret;
}
data->new_data = buff[0] & BME680_MSK_NEW_DATA;
data->heatr_stab = buff[14] & <API key>;
adc_press = (u32_t)(((u32_t)buff[2] << 12) | ((u32_t)buff[3] << 4)
| ((u32_t)buff[4] >> 4));
adc_temp = (u32_t)(((u32_t)buff[5] << 12) | ((u32_t)buff[6] << 4)
| ((u32_t)buff[7] >> 4));
adc_hum = (u16_t)(((u32_t)buff[8] << 8) | (u32_t)buff[9]);
adc_gas_res = (u16_t)((u32_t)buff[13] << 2 | (((u32_t)buff[14]) >> 6));
gas_range = buff[14] & <API key>;
if (data->new_data) {
bme680_calc_temp(data, adc_temp);
bme680_calc_press(data, adc_press);
<API key>(data, adc_hum);
<API key>(data, gas_range, adc_gas_res);
}
/* Trigger the next measurement */
ret = bme680_reg_write(data, <API key>,
<API key>);
if (ret < 0) {
return ret;
}
return 0;
}
static int bme680_channel_get(struct device *dev, enum sensor_channel chan,
struct sensor_value *val)
{
struct bme680_data *data = dev->driver_data;
switch (chan) {
case <API key>:
/*
* data->calc_temp has a resolution of 0.01 degC.
* So 5123 equals 51.23 degC.
*/
val->val1 = data->calc_temp / 100;
val->val2 = data->calc_temp % 100 * 10000;
break;
case SENSOR_CHAN_PRESS:
/*
* data->calc_press has a resolution of 1 Pa.
* So 96321 equals 96.321 kPa.
*/
val->val1 = data->calc_press / 1000;
val->val2 = (data->calc_press % 1000) * 1000;
break;
case <API key>:
/*
* data->calc_humidity has a resolution of 0.001 %RH.
* So 46333 equals 46.333 %RH.
*/
val->val1 = data->calc_humidity / 1000;
val->val2 = (data->calc_humidity % 1000) * 1000;
break;
case SENSOR_CHAN_GAS_RES:
/*
* data->calc_gas_resistance has a resolution of 1 ohm.
* So 100000 equals 100000 ohms.
*/
val->val1 = data->calc_gas_resistance;
val->val2 = 0;
break;
default:
return -EINVAL;
}
return 0;
}
static int <API key>(struct bme680_data *data)
{
u8_t buff[<API key>];
int err = 0;
err = bme680_reg_read(data, BME680_REG_COEFF1, buff, BME680_LEN_COEFF1);
if (err < 0) {
return err;
}
err = bme680_reg_read(data, BME680_REG_COEFF2, &buff[BME680_LEN_COEFF1],
16);
if (err < 0) {
return err;
}
err = bme680_reg_read(data, BME680_REG_COEFF3,
&buff[BME680_LEN_COEFF1 + BME680_LEN_COEFF2],
BME680_LEN_COEFF3);
if (err < 0) {
return err;
}
/* Temperature related coefficients */
data->par_t1 = (u16_t)(BME680_CONCAT_BYTES(buff[32], buff[31]));
data->par_t2 = (s16_t)(BME680_CONCAT_BYTES(buff[1], buff[0]));
data->par_t3 = (u8_t)(buff[2]);
/* Pressure related coefficients */
data->par_p1 = (u16_t)(BME680_CONCAT_BYTES(buff[5], buff[4]));
data->par_p2 = (s16_t)(BME680_CONCAT_BYTES(buff[7], buff[6]));
data->par_p3 = (s8_t)buff[8];
data->par_p4 = (s16_t)(BME680_CONCAT_BYTES(buff[11], buff[10]));
data->par_p5 = (s16_t)(BME680_CONCAT_BYTES(buff[13], buff[12]));
data->par_p6 = (s8_t)(buff[15]);
data->par_p7 = (s8_t)(buff[14]);
data->par_p8 = (s16_t)(BME680_CONCAT_BYTES(buff[19], buff[18]));
data->par_p9 = (s16_t)(BME680_CONCAT_BYTES(buff[21], buff[20]));
data->par_p10 = (u8_t)(buff[22]);
/* Humidity related coefficients */
data->par_h1 = (u16_t)(((u16_t)buff[25] << 4) | (buff[24] & 0x0f));
data->par_h2 = (u16_t)(((u16_t)buff[23] << 4) | ((buff[24]) >> 4));
data->par_h3 = (s8_t)buff[26];
data->par_h4 = (s8_t)buff[27];
data->par_h5 = (s8_t)buff[28];
data->par_h6 = (u8_t)buff[29];
data->par_h7 = (s8_t)buff[30];
/* Gas heater related coefficients */
data->par_gh1 = (s8_t)buff[35];
data->par_gh2 = (s16_t)(BME680_CONCAT_BYTES(buff[34], buff[33]));
data->par_gh3 = (s8_t)buff[36];
data->res_heat_val = (s8_t)buff[37];
data->res_heat_range = ((buff[39] & BME680_MSK_RH_RANGE) >> 4);
data->range_sw_err = ((s8_t)(buff[41] & <API key>)) / 16;
return 0;
}
static int bme680_chip_init(struct device *dev)
{
struct bme680_data *data = (struct bme680_data *)dev->driver_data;
int err;
err = bme680_reg_read(data, BME680_REG_CHIP_ID, &data->chip_id, 1);
if (err < 0) {
return err;
}
if (data->chip_id == BME680_CHIP_ID) {
LOG_ERR("BME680 chip detected");
} else {
LOG_ERR("Bad BME680 chip id 0x%x", data->chip_id);
return -ENOTSUP;
}
err = <API key>(data);
if (err < 0) {
return err;
}
err = bme680_reg_write(data, BME680_REG_CTRL_HUM, <API key>);
if (err < 0) {
return err;
}
err = bme680_reg_write(data, BME680_REG_CONFIG, BME680_CONFIG_VAL);
if (err < 0) {
return err;
}
err = bme680_reg_write(data, <API key>,
<API key>);
if (err < 0) {
return err;
}
err = bme680_reg_write(data, <API key>,
<API key>(data, BME680_HEATR_TEMP));
if (err < 0) {
return err;
}
err = bme680_reg_write(data, <API key>,
<API key>(BME680_HEATR_DUR_MS));
if (err < 0) {
return err;
}
err = bme680_reg_write(data, <API key>,
<API key>);
if (err < 0) {
return err;
}
return 0;
}
static int bme680_init(struct device *dev)
{
struct bme680_data *data = dev->driver_data;
data->i2c_master = device_get_binding(
<API key>);
if (!data->i2c_master) {
LOG_ERR("I2C master not found: %s",
<API key>);
return -EINVAL;
}
data->i2c_slave_addr = <API key>;
if (bme680_chip_init(dev) < 0) {
return -EINVAL;
}
return 0;
}
static const struct sensor_driver_api bme680_api_funcs = {
.sample_fetch = bme680_sample_fetch,
.channel_get = bme680_channel_get,
};
static struct bme680_data bme680_data;
DEVICE_AND_API_INIT(bme680, <API key>, bme680_init, &bme680_data,
NULL, POST_KERNEL, <API key>,
&bme680_api_funcs);
|
var crypto = require("crypto"),
Request = require("./../request"),
Response = require("./../response");
module.exports = sessionCookie;
/**
* A middleware for storing and retrieving session data using HTTP cookies.
* The `options` may be any of the following:
*
* - secret A secret string to use to verify the cookie's contents,
* defaults to `null`. If this is set the session's contents
* will be cleared if the cookie has been tampered with
* - name The name of the cookie, defaults to "strata.session"
* - path The path of the cookie, defaults to "/"
* - domain The cookie's domain, defaults to `null`
* - expireAfter A number of seconds after which this cookie will expire,
* defaults to `null`
* - secure True to only send this cookie over HTTPS, defaults to `false`
* - httpOnly True to only send this cookie over HTTP, defaults to `true`
*/
function sessionCookie(app, options) {
var readSession = sessionCookieReader(options);
var writeSession = sessionCookieWriter(options);
return function (env, callback) {
if (env.session) {
app(env, callback);
return;
}
readSession(env, function (err, session) {
if (err) {
env.session = {};
} else {
env.session = session;
}
app(env, function (status, headers, body) {
var res = new Response(body, headers, status);
writeSession(env, res);
res.send(callback);
});
});
}
}
function sessionCookieReader(options) {
options = <API key>(options);
return function readSessionCookie(env, callback) {
var req = new Request(env);
req.cookies(function (err, cookies) {
if (err) {
callback(err, cookies);
return;
}
var cookie = cookies[options.name];
if (cookie) {
cookie = new Buffer(cookie, "base64").toString("utf8");
var parts = cookie.split("
data = parts[0],
digest = parts[1];
if (digest === sessionDigest(data, options.secret)) {
try {
callback(null, JSON.parse(data));
return;
} catch (e) {
// The cookie does not contain valid JSON.
callback(e, {});
return;
}
}
}
callback(null, {});
});
}
}
function sessionCookieWriter(options) {
options = <API key>(options);
return function writeSessionCookie(env, res) {
var session = env.session;
if (session) {
var data = JSON.stringify(session);
var digest = sessionDigest(data, options.secret);
var cookie = new Buffer(data + "--" + digest, "utf8").toString("base64");
if (cookie.length > 4096) {
env.error.write("Session cookie data size exceeds 4k; content dropped\n");
return;
}
var cookieOptions = {
value: cookie,
path: options.path,
domain: options.domain,
secure: options.secure,
httpOnly: options.httpOnly
};
if (options.expireAfter) {
// expireAfter is given in seconds.
var expires = new Date().getTime() + (options.expireAfter * 1000);
cookieOptions.expires = new Date(expires);
}
res.setCookie(options.name, cookieOptions);
}
}
}
function sessionDigest(data, secret) {
var shasum = crypto.createHash("sha1");
shasum.update(data);
if (secret) {
shasum.update(secret);
}
return shasum.digest("hex");
}
/**
* Creates a new options object from the given session cookie `options` with
* sane defaults.
*/
function <API key>(options) {
options = options || {};
var opts = {
secret: options.secret || null,
name: options.name || "strata.session",
path: options.path || "/",
domain: options.domain || null,
expireAfter: options.expireAfter || null,
secure: options.secure || false
};
if ("httpOnly" in options) {
opts.httpOnly = options.httpOnly || false;
} else {
opts.httpOnly = true;
}
return opts;
}
|
use inkwell::context::Context;
use inkwell::values::{BasicValue, InstructionOpcode::*};
use inkwell::{AddressSpace, AtomicOrdering, AtomicRMWBinOp, FloatPredicate, IntPredicate};
#[test]
fn test_operands() {
let context = Context::create();
let module = context.create_module("ivs");
let builder = context.create_builder();
let void_type = context.void_type();
let f32_type = context.f32_type();
let f32_ptr_type = f32_type.ptr_type(AddressSpace::Generic);
let fn_type = void_type.fn_type(&[f32_ptr_type.into()], false);
let function = module.add_function("take_f32_ptr", fn_type, None);
let basic_block = context.append_basic_block(function, "entry");
builder.position_at_end(basic_block);
let arg1 = function.get_first_param().unwrap().into_pointer_value();
let f32_val = f32_type.const_float(::std::f64::consts::PI);
let store_instruction = builder.build_store(arg1, f32_val);
let free_instruction = builder.build_free(arg1);
let return_instruction = builder.build_return(None);
assert_eq!(store_instruction.get_opcode(), Store);
assert_eq!(free_instruction.get_opcode(), Call);
assert_eq!(return_instruction.get_opcode(), Return);
assert!(arg1.<API key>().is_none());
// Test operands
assert_eq!(store_instruction.get_num_operands(), 2);
assert_eq!(free_instruction.get_num_operands(), 2);
let store_operand0 = store_instruction.get_operand(0).unwrap();
let store_operand1 = store_instruction.get_operand(1).unwrap();
assert_eq!(store_operand0.left().unwrap(), f32_val); // f32 const
assert_eq!(store_operand1.left().unwrap(), arg1); // f32* arg1
assert!(store_instruction.get_operand(2).is_none());
assert!(store_instruction.get_operand(3).is_none());
assert!(store_instruction.get_operand(4).is_none());
let free_operand0 = free_instruction.get_operand(0).unwrap().left().unwrap();
let free_operand1 = free_instruction.get_operand(1).unwrap().left().unwrap();
let <API key> = free_operand0.<API key>().unwrap();
assert!(free_operand0.is_pointer_value()); // (implictly casted) i8* arg1
assert!(free_operand1.is_pointer_value()); // Free function ptr
assert_eq!(<API key>.get_opcode(), BitCast);
assert_eq!(<API key>.get_operand(0).unwrap().left().unwrap(), arg1);
assert!(<API key>.get_operand(1).is_none());
assert!(<API key>.get_operand(2).is_none());
assert!(free_instruction.get_operand(2).is_none());
assert!(free_instruction.get_operand(3).is_none());
assert!(free_instruction.get_operand(4).is_none());
assert!(module.verify().is_ok());
assert!(free_instruction.set_operand(0, arg1));
// Module is no longer valid because free takes an i8* not f32*
assert!(module.verify().is_err());
assert!(free_instruction.set_operand(0, free_operand0));
assert!(module.verify().is_ok());
// No-op, free only has two (0-1) operands
assert!(!free_instruction.set_operand(2, free_operand0));
assert!(module.verify().is_ok());
assert_eq!(return_instruction.get_num_operands(), 0);
assert!(return_instruction.get_operand(0).is_none());
assert!(return_instruction.get_operand(1).is_none());
assert!(return_instruction.get_operand(2).is_none());
// Test Uses
let bitcast_use_value = <API key>
.get_first_use()
.unwrap()
.get_used_value()
.left()
.unwrap();
let free_call_param = free_instruction.get_operand(0).unwrap().left().unwrap();
assert_eq!(bitcast_use_value, free_call_param);
// These instructions/calls don't return any ir value so they aren't used anywhere
assert!(store_instruction.get_first_use().is_none());
assert!(free_instruction.get_first_use().is_none());
assert!(return_instruction.get_first_use().is_none());
// arg1 (%0) has two uses:
// store float 0x400921FB60000000, float* %0
// %1 = bitcast float* %0 to i8*
let arg1_first_use = arg1.get_first_use().unwrap();
let arg1_second_use = arg1_first_use.get_next_use().unwrap();
// However their operands are used
let store_operand_use0 = store_instruction.get_operand_use(0).unwrap();
let store_operand_use1 = store_instruction.get_operand_use(1).unwrap();
assert!(store_operand_use0.get_next_use().is_none());
assert!(store_operand_use1.get_next_use().is_none());
assert_eq!(store_operand_use1, arg1_second_use);
assert_eq!(store_operand_use0.get_user().<API key>(), store_instruction);
assert_eq!(store_operand_use1.get_user().<API key>(), store_instruction);
assert_eq!(store_operand_use0.get_used_value().left().unwrap(), f32_val);
assert_eq!(store_operand_use1.get_used_value().left().unwrap(), arg1);
assert!(store_instruction.get_operand_use(2).is_none());
assert!(store_instruction.get_operand_use(3).is_none());
assert!(store_instruction.get_operand_use(4).is_none());
assert!(store_instruction.get_operand_use(5).is_none());
assert!(store_instruction.get_operand_use(6).is_none());
let free_operand_use0 = free_instruction.get_operand_use(0).unwrap();
let free_operand_use1 = free_instruction.get_operand_use(1).unwrap();
assert!(free_operand_use0.get_next_use().is_none());
assert!(free_operand_use1.get_next_use().is_none());
assert!(free_instruction.get_operand_use(2).is_none());
assert!(free_instruction.get_operand_use(3).is_none());
assert!(free_instruction.get_operand_use(4).is_none());
assert!(free_instruction.get_operand_use(5).is_none());
assert!(free_instruction.get_operand_use(6).is_none());
assert!(module.verify().is_ok());
}
#[test]
fn <API key>() {
let context = Context::create();
let module = context.create_module("ivs");
let builder = context.create_builder();
let void_type = context.void_type();
let fn_type = void_type.fn_type(&[], false);
let function = module.add_function("bb_op", fn_type, None);
let basic_block = context.append_basic_block(function, "entry");
let basic_block2 = context.append_basic_block(function, "exit");
builder.position_at_end(basic_block);
let branch_instruction = builder.<API key>(basic_block2);
let bb_operand = branch_instruction.get_operand(0).unwrap().right().unwrap();
assert_eq!(bb_operand, basic_block2);
let bb_operand_use = branch_instruction.get_operand_use(0).unwrap();
assert_eq!(bb_operand_use.get_used_value().right().unwrap(), basic_block2);
builder.position_at_end(basic_block2);
builder.build_return(None);
assert!(module.verify().is_ok());
}
#[test]
fn test_get_next_use() {
let context = Context::create();
let module = context.create_module("ivs");
let builder = context.create_builder();
let f32_type = context.f32_type();
let fn_type = f32_type.fn_type(&[f32_type.into()], false);
let function = module.add_function("take_f32", fn_type, None);
let basic_block = context.append_basic_block(function, "entry");
builder.position_at_end(basic_block);
let arg1 = function.get_first_param().unwrap().into_float_value();
let f32_val = f32_type.const_float(::std::f64::consts::PI);
let add_pi0 = builder.build_float_add(arg1, f32_val, "add_pi");
let add_pi1 = builder.build_float_add(add_pi0, f32_val, "add_pi");
builder.build_return(Some(&add_pi1));
// f32_val constant appears twice, so there are two uses (first, next)
let first_use = f32_val.get_first_use().unwrap();
assert_eq!(first_use.get_user(), add_pi1.<API key>().unwrap());
assert_eq!(first_use.get_next_use().map(|x| x.get_user().into_float_value()), Some(add_pi0));
assert!(arg1.get_first_use().is_some());
assert!(module.verify().is_ok());
}
#[test]
fn test_instructions() {
let context = Context::create();
let module = context.create_module("testing");
let builder = context.create_builder();
let void_type = context.void_type();
let i64_type = context.i64_type();
let f32_type = context.f32_type();
let f32_ptr_type = f32_type.ptr_type(AddressSpace::Generic);
let fn_type = void_type.fn_type(&[f32_ptr_type.into(), f32_type.into()], false);
let function = module.add_function("free_f32", fn_type, None);
let basic_block = context.append_basic_block(function, "entry");
builder.position_at_end(basic_block);
let arg1 = function.get_first_param().unwrap().into_pointer_value();
let arg2 = function.get_nth_param(1).unwrap().into_float_value();
assert!(arg1.get_first_use().is_none());
assert!(arg2.get_first_use().is_none());
let f32_val = f32_type.const_float(::std::f64::consts::PI);
let store_instruction = builder.build_store(arg1, f32_val);
let ptr_val = builder.build_ptr_to_int(arg1, i64_type, "ptr_val");
let ptr = builder.build_int_to_ptr(ptr_val, f32_ptr_type, "ptr");
let icmp = builder.build_int_compare(IntPredicate::EQ, ptr_val, ptr_val, "icmp");
let f32_sum = builder.build_float_add(arg2, f32_val, "f32_sum");
let fcmp = builder.build_float_compare(FloatPredicate::OEQ, f32_sum, arg2, "fcmp");
let free_instruction = builder.build_free(arg1);
let return_instruction = builder.build_return(None);
assert_eq!(store_instruction.get_opcode(), Store);
assert_eq!(ptr_val.as_instruction().unwrap().get_opcode(), PtrToInt);
assert_eq!(ptr.as_instruction().unwrap().get_opcode(), IntToPtr);
assert_eq!(icmp.as_instruction().unwrap().get_opcode(), ICmp);
assert_eq!(ptr.as_instruction().unwrap().get_icmp_predicate(), None);
assert_eq!(icmp.as_instruction().unwrap().get_icmp_predicate().unwrap(), IntPredicate::EQ);
assert_eq!(f32_sum.as_instruction().unwrap().get_opcode(), FAdd);
assert_eq!(fcmp.as_instruction().unwrap().get_opcode(), FCmp);
assert_eq!(f32_sum.as_instruction().unwrap().get_fcmp_predicate(), None);
assert_eq!(icmp.as_instruction().unwrap().get_fcmp_predicate(), None);
assert_eq!(fcmp.as_instruction().unwrap().get_fcmp_predicate().unwrap(), FloatPredicate::OEQ);
assert_eq!(free_instruction.get_opcode(), Call);
assert_eq!(return_instruction.get_opcode(), Return);
// test instruction cloning
let instruction_clone = return_instruction.clone();
assert_eq!(instruction_clone.get_opcode(), return_instruction.get_opcode());
assert_ne!(instruction_clone, return_instruction);
// test copying
let <API key> = instruction_clone;
assert_eq!(instruction_clone, <API key>);
}
#[llvm_versions(10.0..=latest)]
#[test]
fn <API key>() {
let context = Context::create();
let module = context.create_module("testing");
let builder = context.create_builder();
let void_type = context.void_type();
let i32_type = context.i32_type();
let i32_ptr_type = i32_type.ptr_type(AddressSpace::Generic);
let fn_type = void_type.fn_type(&[i32_ptr_type.into(), i32_type.into()], false);
let function = module.add_function("mem_inst", fn_type, None);
let basic_block = context.append_basic_block(function, "entry");
builder.position_at_end(basic_block);
let arg1 = function.get_first_param().unwrap().into_pointer_value();
let arg2 = function.get_nth_param(1).unwrap().into_int_value();
assert!(arg1.get_first_use().is_none());
assert!(arg2.get_first_use().is_none());
let i32_val = i32_type.const_int(7, false);
let atomicrmw = builder
.build_atomicrmw(AtomicRMWBinOp::Add, arg1, arg2, AtomicOrdering::Unordered)
.unwrap()
.<API key>()
.unwrap();
let cmpxchg = builder
.build_cmpxchg(
arg1,
arg2,
i32_val,
AtomicOrdering::Monotonic,
AtomicOrdering::Monotonic,
)
.unwrap()
.<API key>()
.unwrap();
assert_eq!(atomicrmw.get_volatile().unwrap(), false);
assert_eq!(cmpxchg.get_volatile().unwrap(), false);
atomicrmw.set_volatile(true).unwrap();
cmpxchg.set_volatile(true).unwrap();
assert_eq!(atomicrmw.get_volatile().unwrap(), true);
assert_eq!(cmpxchg.get_volatile().unwrap(), true);
atomicrmw.set_volatile(false).unwrap();
cmpxchg.set_volatile(false).unwrap();
assert_eq!(atomicrmw.get_volatile().unwrap(), false);
assert_eq!(cmpxchg.get_volatile().unwrap(), false);
}
#[llvm_versions(3.6..=10.0)]
#[test]
fn <API key>() {
let context = Context::create();
let module = context.create_module("testing");
let builder = context.create_builder();
let void_type = context.void_type();
let f32_type = context.f32_type();
let f32_ptr_type = f32_type.ptr_type(AddressSpace::Generic);
let fn_type = void_type.fn_type(&[f32_ptr_type.into(), f32_type.into()], false);
let function = module.add_function("mem_inst", fn_type, None);
let basic_block = context.append_basic_block(function, "entry");
builder.position_at_end(basic_block);
let arg1 = function.get_first_param().unwrap().into_pointer_value();
let arg2 = function.get_nth_param(1).unwrap().into_float_value();
assert!(arg1.get_first_use().is_none());
assert!(arg2.get_first_use().is_none());
let f32_val = f32_type.const_float(::std::f64::consts::PI);
let store_instruction = builder.build_store(arg1, f32_val);
let load = builder.build_load(arg1, "");
let load_instruction = load.<API key>().unwrap();
assert_eq!(store_instruction.get_volatile().unwrap(), false);
assert_eq!(load_instruction.get_volatile().unwrap(), false);
store_instruction.set_volatile(true).unwrap();
load_instruction.set_volatile(true).unwrap();
assert_eq!(store_instruction.get_volatile().unwrap(), true);
assert_eq!(load_instruction.get_volatile().unwrap(), true);
store_instruction.set_volatile(false).unwrap();
load_instruction.set_volatile(false).unwrap();
assert_eq!(store_instruction.get_volatile().unwrap(), false);
assert_eq!(load_instruction.get_volatile().unwrap(), false);
assert_eq!(store_instruction.get_alignment().unwrap(), 0);
assert_eq!(load_instruction.get_alignment().unwrap(), 0);
assert!(store_instruction.set_alignment(16).is_ok());
assert!(load_instruction.set_alignment(16).is_ok());
assert_eq!(store_instruction.get_alignment().unwrap(), 16);
assert_eq!(load_instruction.get_alignment().unwrap(), 16);
assert!(store_instruction.set_alignment(0).is_ok());
assert!(load_instruction.set_alignment(0).is_ok());
assert_eq!(store_instruction.get_alignment().unwrap(), 0);
assert_eq!(load_instruction.get_alignment().unwrap(), 0);
assert!(store_instruction.set_alignment(14).is_err());
assert_eq!(store_instruction.get_alignment().unwrap(), 0);
let fadd_instruction = builder.build_float_add(load.into_float_value(), f32_val, "").<API key>().unwrap();
assert!(fadd_instruction.get_volatile().is_err());
assert!(fadd_instruction.set_volatile(false).is_err());
assert!(fadd_instruction.get_alignment().is_err());
assert!(fadd_instruction.set_alignment(16).is_err());
}
#[llvm_versions(11.0..=latest)]
#[test]
fn <API key>() {
let context = Context::create();
let module = context.create_module("testing");
let builder = context.create_builder();
let void_type = context.void_type();
let f32_type = context.f32_type();
let f32_ptr_type = f32_type.ptr_type(AddressSpace::Generic);
let fn_type = void_type.fn_type(&[f32_ptr_type.into(), f32_type.into()], false);
let function = module.add_function("mem_inst", fn_type, None);
let basic_block = context.append_basic_block(function, "entry");
builder.position_at_end(basic_block);
let arg1 = function.get_first_param().unwrap().into_pointer_value();
let arg2 = function.get_nth_param(1).unwrap().into_float_value();
assert!(arg1.get_first_use().is_none());
assert!(arg2.get_first_use().is_none());
let f32_val = f32_type.const_float(::std::f64::consts::PI);
let store_instruction = builder.build_store(arg1, f32_val);
let load = builder.build_load(arg1, "");
let load_instruction = load.<API key>().unwrap();
assert_eq!(store_instruction.get_volatile().unwrap(), false);
assert_eq!(load_instruction.get_volatile().unwrap(), false);
store_instruction.set_volatile(true).unwrap();
load_instruction.set_volatile(true).unwrap();
assert_eq!(store_instruction.get_volatile().unwrap(), true);
assert_eq!(load_instruction.get_volatile().unwrap(), true);
store_instruction.set_volatile(false).unwrap();
load_instruction.set_volatile(false).unwrap();
assert_eq!(store_instruction.get_volatile().unwrap(), false);
assert_eq!(load_instruction.get_volatile().unwrap(), false);
assert_eq!(store_instruction.get_alignment().unwrap(), 4);
assert_eq!(load_instruction.get_alignment().unwrap(), 4);
assert!(store_instruction.set_alignment(16).is_ok());
assert!(load_instruction.set_alignment(16).is_ok());
assert_eq!(store_instruction.get_alignment().unwrap(), 16);
assert_eq!(load_instruction.get_alignment().unwrap(), 16);
assert!(store_instruction.set_alignment(4).is_ok());
assert!(load_instruction.set_alignment(4).is_ok());
assert_eq!(store_instruction.get_alignment().unwrap(), 4);
assert_eq!(load_instruction.get_alignment().unwrap(), 4);
assert!(store_instruction.set_alignment(14).is_err());
assert_eq!(store_instruction.get_alignment().unwrap(), 4);
let fadd_instruction = builder.build_float_add(load.into_float_value(), f32_val, "").<API key>().unwrap();
assert!(fadd_instruction.get_volatile().is_err());
assert!(fadd_instruction.set_volatile(false).is_err());
assert!(fadd_instruction.get_alignment().is_err());
assert!(fadd_instruction.set_alignment(16).is_err());
}
#[llvm_versions(3.8..=latest)]
#[test]
fn <API key>() {
let context = Context::create();
let module = context.create_module("testing");
let builder = context.create_builder();
let void_type = context.void_type();
let f32_type = context.f32_type();
let f32_ptr_type = f32_type.ptr_type(AddressSpace::Generic);
let fn_type = void_type.fn_type(&[f32_ptr_type.into(), f32_type.into()], false);
let function = module.add_function("mem_inst", fn_type, None);
let basic_block = context.append_basic_block(function, "entry");
builder.position_at_end(basic_block);
let arg1 = function.get_first_param().unwrap().into_pointer_value();
let arg2 = function.get_nth_param(1).unwrap().into_float_value();
assert!(arg1.get_first_use().is_none());
assert!(arg2.get_first_use().is_none());
let f32_val = f32_type.const_float(::std::f64::consts::PI);
let store_instruction = builder.build_store(arg1, f32_val);
let load = builder.build_load(arg1, "");
let load_instruction = load.<API key>().unwrap();
assert_eq!(store_instruction.get_atomic_ordering().unwrap(), AtomicOrdering::NotAtomic);
assert_eq!(load_instruction.get_atomic_ordering().unwrap(), AtomicOrdering::NotAtomic);
assert!(store_instruction.set_atomic_ordering(AtomicOrdering::Monotonic).is_ok());
assert_eq!(store_instruction.get_atomic_ordering().unwrap(), AtomicOrdering::Monotonic);
assert!(store_instruction.set_atomic_ordering(AtomicOrdering::Release).is_ok());
assert!(load_instruction.set_atomic_ordering(AtomicOrdering::Acquire).is_ok());
assert!(store_instruction.set_atomic_ordering(AtomicOrdering::Acquire).is_err());
assert!(store_instruction.set_atomic_ordering(AtomicOrdering::AcquireRelease).is_err());
assert!(load_instruction.set_atomic_ordering(AtomicOrdering::AcquireRelease).is_err());
assert!(load_instruction.set_atomic_ordering(AtomicOrdering::Release).is_err());
let fadd_instruction = builder.build_float_add(load.into_float_value(), f32_val, "").<API key>().unwrap();
assert!(fadd_instruction.get_atomic_ordering().is_err());
assert!(fadd_instruction.set_atomic_ordering(AtomicOrdering::NotAtomic).is_err());
}
#[test]
fn test_metadata_kinds() {
let context = Context::create();
let i8_type = context.i8_type();
let f32_type = context.f32_type();
let ptr_type = i8_type.ptr_type(AddressSpace::Generic);
let struct_type = context.struct_type(&[i8_type.into(), f32_type.into()], false);
let vector_type = i8_type.vec_type(2);
let i8_value = i8_type.const_zero();
let i8_array_value = i8_type.const_array(&[i8_value]);
let f32_value = f32_type.const_zero();
let ptr_value = ptr_type.const_null();
let struct_value = struct_type.get_undef();
let vector_value = vector_type.const_zero();
let md_string = context.metadata_string("lots of metadata here");
context.metadata_node(&[
i8_array_value.into(),
i8_value.into(),
f32_value.into(),
ptr_value.into(),
struct_value.into(),
vector_value.into(),
md_string.into(),
]);
}
|
package org.efix.util.buffer;
import org.efix.util.ByteSequenceWrapper;
import org.efix.util.StringUtil;
public class BufferUtil {
public static UnsafeBuffer fromString(String string) {
return new UnsafeBuffer(StringUtil.asciiBytes(string));
}
public static String toString(Buffer buffer) {
return toString(buffer, 0, buffer.capacity());
}
public static String toString(Buffer buffer, int offset, int length) {
return new ByteSequenceWrapper(buffer, offset, length).toString();
}
}
|
package dao
import (
"go-common/app/admin/ep/merlin/model"
"testing"
. "github.com/smartystreets/goconvey/convey"
)
var (
username = "fengyifenguitest@bilibili.com"
)
func Test_Mail_Log(t *testing.T) {
Convey("test add mail log", t, func() {
ml := &model.MailLog{
ReceiverName: username,
MailType: 1,
SendContext: "test add mail log",
}
err := d.InsertMailLog(ml)
So(err, ShouldBeNil)
})
Convey("test find mail log", t, func() {
mailLogs, err := d.FindMailLog(username)
So(len(mailLogs), ShouldBeGreaterThan, 0)
So(err, ShouldBeNil)
})
Convey("test delete mail log", t, func() {
err := d.DelMailLog(username)
So(err, ShouldBeNil)
})
Convey("test find mail log", t, func() {
mailLogs, err := d.FindMailLog(username)
So(len(mailLogs), ShouldEqual, 0)
So(err, ShouldBeNil)
})
}
|
<!DOCTYPE html>
<html layout:decorate="~{layouts/adminlte}">
<head>
<title>FormKiQ Server - Setup</title>
</head>
<body>
<div layout:fragment="content">
<!-- Main content -->
<section class="content">
<div class="row">
<form method="post">
<div class="box-body">
<th:block
th:with="form=${flow.currentState.data},fielderrors=${flow.currentState.fielderrors}"
th:if="${!flow.currentState.end}"
th:include="fragments/component/form" />
<th:block
th:with="form=${T(com.formkiq.forms.JSONService).instance().loadForm('com.formkiq.core.service.dto.Setupcomplete.form')}"
th:if="${flow.currentState.end}"
th:include="fragments/component/form" />
</div>
</form>
</div>
</section>
</div>
</body>
</html>
|
import styled, { css as styledCss, keyframes } from 'styled-components'
import type { TTestable } from '@/spec'
import Img from '@/Img'
import { theme } from '@/utils/themes'
import css from '@/utils/css'
const DURATION = '2.5s'
const load = keyframes`
0% {
top: 24px;
}
70% {
top: 10px;
}
90% {
top: 0;
}
95% {
top: 0;
}
100% {
top: 24px;
}
`
const liquid1 = keyframes`
0% {
height: 0;
opacity: 0;
top: -5px;
}
22% {
height: 2.8125px;
top: 3.75px;
opacity: 1;
}
25% {
top: -2.5px;
}
35% {
height: 11.25px;
top: -5px;
}
55% {
height: 3px;
top: -1.25px;
}
60% {
height: 6px;
opacity: 1;
top: -3px;
}
96% {
height: 8.4375px;
opacity: 0;
top: 5px;
}
100% {
height: 0;
opacity: 0;
}
`
const liquid2 = keyframes`
0% {
height: 0;
opacity: 0;
top: -0.5rem;
}
17.5% {
height: 3px;
top: 2px;
opacity: 1;
}
20% {
top: -2.5px;
}
25% {
height: 15px;
top: -6px;
}
45% {
height: 3px;
top: -1px;
}
60% {
opacity: 1;
height: 15px;
top: -5px;
}
96% {
opacity: 0;
height: 8px;
top: 5px;
}
100% {
height: 0;
opacity: 0;
}
`
const loadRule = styledCss`
${load} ${DURATION} infinite;
`
const liquid1Rule = styledCss`
${liquid1} ${DURATION} infinite;
`
const liquid2Rule = styledCss`
${liquid2} ${DURATION} infinite;
`
export const Wrapper = styled.div.attrs(({ testid }: TTestable) => ({
'data-test-id': testid,
}))<TTestable>`
text-align: center;
position: relative;
height: 28px;
margin-bottom: 6px;
cursor: pointer;
`
export const Battery = styled.div`
display: inline-block;
position: relative;
width: 16px;
height: 26px;
box-shadow: 0 0 0 2px #155e76;
border-radius: 2px;
&:before {
content: '';
position: absolute;
left: 5px;
top: -4px;
height: 3px;
width: 6px;
background: #155e76;
border-radius: 2px;
}
${Wrapper}:hover & {
&:after {
content: '';
position: absolute;
top: 0;
bottom: 0;
left: 0;
right: 0;
border-right: 16px solid transparent;
border-bottom: 22px solid rgba(255, 255, 255, 0.25);
}
}
`
export const Liquid = styled.div`
position: absolute;
top: 23px;
bottom: 0;
left: 0;
right: 0;
width: 16px;
background: ${theme('baseColor.green')};
${Wrapper}:hover & {
top: 0;
animation: ${loadRule};
&:before {
left: 0;
animation: ${liquid2Rule};
content: '';
position: absolute;
top: -5px;
height: 11.25px;
width: 14.625px;
background: ${theme('baseColor.green')};
border-radius: 50%;
opacity: 0;
}
&:after {
right: 0;
animation: ${liquid1Rule};
content: '';
position: absolute;
top: -5px;
height: 11.25px;
width: 14.625px;
background: ${theme('baseColor.green')};
border-radius: 50%;
opacity: 0;
}
}
`
export const MoneySign = styled(Img)`
position: absolute;
top: 6px;
left: 3px;
${css.size(10)};
fill: #327faf;
transition: opacity 0.25s;
${Wrapper}:hover & {
fill: #ecbcb3;
top: 8px;
left: 2px;
${css.size(12)};
}
transition: all 0.2s;
`
|
"""Support for switches which integrates with other components."""
import logging
import voluptuous as vol
from homeassistant.components.switch import (
ENTITY_ID_FORMAT,
PLATFORM_SCHEMA,
SwitchEntity,
)
from homeassistant.const import (
ATTR_ENTITY_ID,
ATTR_FRIENDLY_NAME,
<API key>,
CONF_ICON_TEMPLATE,
CONF_SWITCHES,
CONF_UNIQUE_ID,
CONF_VALUE_TEMPLATE,
STATE_OFF,
STATE_ON,
)
from homeassistant.core import callback
from homeassistant.exceptions import TemplateError
import homeassistant.helpers.config_validation as cv
from homeassistant.helpers.entity import <API key>
from homeassistant.helpers.reload import <API key>
from homeassistant.helpers.restore_state import RestoreEntity
from homeassistant.helpers.script import Script
from .const import <API key>, DOMAIN, PLATFORMS
from .template_entity import TemplateEntity
_LOGGER = logging.getLogger(__name__)
_VALID_STATES = [STATE_ON, STATE_OFF, "true", "false"]
ON_ACTION = "turn_on"
OFF_ACTION = "turn_off"
SWITCH_SCHEMA = vol.Schema(
{
vol.Optional(CONF_VALUE_TEMPLATE): cv.template,
vol.Optional(CONF_ICON_TEMPLATE): cv.template,
vol.Optional(<API key>): cv.template,
vol.Optional(<API key>): cv.template,
vol.Required(ON_ACTION): cv.SCRIPT_SCHEMA,
vol.Required(OFF_ACTION): cv.SCRIPT_SCHEMA,
vol.Optional(ATTR_FRIENDLY_NAME): cv.string,
vol.Optional(ATTR_ENTITY_ID): cv.entity_ids,
vol.Optional(CONF_UNIQUE_ID): cv.string,
}
)
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(
{vol.Required(CONF_SWITCHES): cv.<API key>(SWITCH_SCHEMA)}
)
async def <API key>(hass, config):
"""Create the Template switches."""
switches = []
for device, device_config in config[CONF_SWITCHES].items():
friendly_name = device_config.get(ATTR_FRIENDLY_NAME, device)
state_template = device_config.get(CONF_VALUE_TEMPLATE)
icon_template = device_config.get(CONF_ICON_TEMPLATE)
<API key> = device_config.get(<API key>)
<API key> = device_config.get(<API key>)
on_action = device_config[ON_ACTION]
off_action = device_config[OFF_ACTION]
unique_id = device_config.get(CONF_UNIQUE_ID)
switches.append(
SwitchTemplate(
hass,
device,
friendly_name,
state_template,
icon_template,
<API key>,
<API key>,
on_action,
off_action,
unique_id,
)
)
return switches
async def <API key>(hass, config, async_add_entities, discovery_info=None):
"""Set up the template switches."""
await <API key>(hass, DOMAIN, PLATFORMS)
async_add_entities(await <API key>(hass, config))
class SwitchTemplate(TemplateEntity, SwitchEntity, RestoreEntity):
"""Representation of a Template switch."""
def __init__(
self,
hass,
device_id,
friendly_name,
state_template,
icon_template,
<API key>,
<API key>,
on_action,
off_action,
unique_id,
):
"""Initialize the Template switch."""
super().__init__(
<API key>=<API key>,
icon_template=icon_template,
<API key>=<API key>,
)
self.entity_id = <API key>(
ENTITY_ID_FORMAT, device_id, hass=hass
)
self._name = friendly_name
self._template = state_template
domain = __name__.split(".")[-2]
self._on_script = Script(hass, on_action, friendly_name, domain)
self._off_script = Script(hass, off_action, friendly_name, domain)
self._state = False
self._unique_id = unique_id
@callback
def _update_state(self, result):
super()._update_state(result)
if isinstance(result, TemplateError):
self._state = None
return
self._state = result.lower() in ("true", STATE_ON)
async def async_added_to_hass(self):
"""Register callbacks."""
if self._template is None:
# restore state after startup
await super().async_added_to_hass()
state = await self.<API key>()
if state:
self._state = state.state == STATE_ON
# no need to listen for events
else:
self.<API key>(
"_state", self._template, None, self._update_state
)
await super().async_added_to_hass()
@property
def name(self):
"""Return the name of the switch."""
return self._name
@property
def unique_id(self):
"""Return the unique id of this switch."""
return self._unique_id
@property
def is_on(self):
"""Return true if device is on."""
return self._state
@property
def should_poll(self):
"""Return the polling state."""
return False
async def async_turn_on(self, **kwargs):
"""Fire the on action."""
await self._on_script.async_run(context=self._context)
if self._template is None:
self._state = True
self.<API key>()
async def async_turn_off(self, **kwargs):
"""Fire the off action."""
await self._off_script.async_run(context=self._context)
if self._template is None:
self._state = False
self.<API key>()
@property
def assumed_state(self):
"""State is assumed, if no template given."""
return self._template is None
|
package org.whale.ext.domain;
import java.util.ArrayList;
import java.util.List;
import org.whale.system.annotation.jdbc.Column;
import org.whale.system.annotation.jdbc.Id;
import org.whale.system.annotation.jdbc.Table;
import org.whale.system.annotation.jdbc.Validate;
import org.whale.system.base.BaseEntry;
import org.whale.system.common.util.PropertiesUtil;
/**
*
*
* @author wjs
* 2014910-10:12:48
*/
@Table(value="sys_domian", cnName="")
public class Domain extends BaseEntry{
private static final long serialVersionUID = -23042834921L;
@Id
@Column(cnName="id")
private Long id;
@Validate(required=true)
@Column(cnName="")
private String domainName;
@Validate(required=true)
@Column(cnName="")
private String domainCnName;
@Validate(required=true)
@Column(cnName="", unique=true)
private String domainSqlName;
@Column(cnName="")
private String pkgName = "org.whale.system";
private Integer treeModel;
private String treeId;
private String treePid;
private String treeName;
private Integer ftlType;
private String codePath;
private String author = PropertiesUtil.getValue("author", "wjs");
private Attr idAttr;
private List<Attr> attrs;
private List<Attr> listAttrs = new ArrayList<Attr>();
private List<Attr> formAttrs = new ArrayList<Attr>();
private List<Attr> queryAttrs = new ArrayList<Attr>();
public Long getId() {
return id;
}
public String getDomainName() {
return domainName;
}
public void setDomainName(String domainName) {
this.domainName = domainName;
}
public String getDomainCnName() {
return domainCnName;
}
public void setDomainCnName(String domainCnName) {
this.domainCnName = domainCnName;
}
public String getDomainSqlName() {
return domainSqlName;
}
public void setDomainSqlName(String domainSqlName) {
this.domainSqlName = domainSqlName;
}
public String getPkgName() {
return pkgName;
}
public void setPkgName(String pkgName) {
this.pkgName = pkgName;
}
public Attr getIdAttr() {
return idAttr;
}
public void setIdAttr(Attr idAttr) {
this.idAttr = idAttr;
}
public List<Attr> getAttrs() {
return attrs;
}
public void setAttrs(List<Attr> attrs) {
this.attrs = attrs;
}
public List<Attr> getListAttrs() {
return listAttrs;
}
public void setListAttrs(List<Attr> listAttrs) {
this.listAttrs = listAttrs;
}
public List<Attr> getFormAttrs() {
return formAttrs;
}
public void setFormAttrs(List<Attr> formAttrs) {
this.formAttrs = formAttrs;
}
public List<Attr> getQueryAttrs() {
return queryAttrs;
}
public void setQueryAttrs(List<Attr> queryAttrs) {
this.queryAttrs = queryAttrs;
}
public void setId(Long id) {
this.id = id;
}
public Integer getFtlType() {
return ftlType;
}
public void setFtlType(Integer ftlType) {
this.ftlType = ftlType;
}
public String getCodePath() {
return codePath;
}
public void setCodePath(String codePath) {
this.codePath = codePath;
}
public Integer getTreeModel() {
return treeModel;
}
public void setTreeModel(Integer treeModel) {
this.treeModel = treeModel;
}
public String getTreeId() {
return treeId;
}
public void setTreeId(String treeId) {
this.treeId = treeId;
}
public String getTreePid() {
return treePid;
}
public void setTreePid(String treePid) {
this.treePid = treePid;
}
public String getTreeName() {
return treeName;
}
public void setTreeName(String treeName) {
this.treeName = treeName;
}
public String getAuthor() {
return author;
}
public void setAuthor(String author) {
this.author = author;
}
}
|
#include "syscall.hpp"
#include <diag\Trace.h>
namespace os {
#if 0
static void dispatch_syscall(void) naked_function;
static void dispatch_syscall(void)
{
__asm__ __volatile__
(
" sub sp, sp, #16\n" /* Create a stack frame to hold 3 parms + lr */
" str r4, [sp, #0]\n" /* Move parameter 4 (if any) into position */
" str r5, [sp, #4]\n" /* Move parameter 5 (if any) into position */
" str r6, [sp, #8]\n" /* Move parameter 6 (if any) into position */
" str lr, [sp, #12]\n" /* Save lr in the stack frame */
" ldr ip, =g_stublookup\n" /* R12=The base of the stub lookup table */
" ldr ip, [ip, r0, lsl #2]\n" /* R12=The address of the stub for this syscall */
" blx ip\n" /* Call the stub (modifies lr) */
" ldr lr, [sp, #12]\n" /* Restore lr */
" add sp, sp, #16\n" /* Destroy the stack frame */
" mov r2, r0\n" /* R2=Save return value in R2 */
" mov r0, #3\n" /* R0=SYS_syscall_return */
" svc 0" /* Return from the syscall */
);
}
#endif
}
#if 0
enum register_stack_t {
/* Saved by hardware */
REG_R0,
REG_R1,
REG_R2,
REG_R3,
REG_R12,
REG_LR,
REG_PC,
REG_xPSR
};
#define RESERVED_STACK \
(8 * sizeof(uint32_t))
static void dispatch_syscall() __attribute((naked));
static void dispatch_syscall(uint32_t* caller) __attribute((naked)){
uint32_t svc_num = ((char *) caller[REG_PC])[-2];
}
void syscall_init(uint8_t nbr, uintptr_t call){
assert(nbr < MAX_SYSCALLS);
caller = call;
}
}
template<uintptr_t FROM, uintptr_t TO> static inline void copy_stack(){
__asm volatile(
"ldr r12, [sp, %0]\n"
"str r12, [sp, %1]\n"
: "i"(FROM), "i"(TO) ::"r12");
}
__attribute((always_inline) )static inline void copy_memory(uintptr from, uintptr_t to)
__attribute((always_inline) )static inline void copy_stack() {
__asm__ __volatile__ ("push {r12 }sub sp, #(8*4)\n");
copy_stack<REG_R0+8, REG_R0>();
}
#endif
//extern "C" void SVC_Handler() __attribute((naked)) ;
#if 0
extern "C" void SVC_Handler() {
assert(0);
}
#endif
|
#include <iostream>
#include <iomanip>
#include <cstdint>
#include <typeinfo>
#include "color/color.hpp"
int main( int argc, char *argv[] )
{
using namespace color;
using namespace std;
cout << "gray<std::uint8_t > is: " << typeid( trait::component< gray< std::uint8_t >::category_type >::instance_type ).name() << endl;
cout << "gray<std::uint32_t> is: " << typeid( trait::component< gray< std::uint32_t >::category_type >::instance_type ).name() << endl;
cout << "gray<float > is: " << typeid( trait::component< gray< float >::category_type >::instance_type ).name() << endl;
cout << "gray<double > is: " << typeid( trait::component< gray< double >::category_type >::instance_type ).name() << endl;
cout << "gray<long double > is: " << typeid( trait::component< gray< long double >::category_type >::instance_type ).name() << endl;
return EXIT_SUCCESS;
}
|
# AUTOGENERATED FILE
FROM balenalib/<API key>:3.10-build
ENV NODE_VERSION 14.16.1
ENV YARN_VERSION 1.22.4
# Install dependencies
RUN apk add --no-cache libgcc libstdc++ libuv \
&& apk add --no-cache libssl1.0 || apk add --no-cache libssl1.1
RUN for key in \
<API key> \
; do \
gpg --keyserver pgp.mit.edu --recv-keys "$key" || \
gpg --keyserver keyserver.pgp.com --recv-keys "$key" || \
gpg --keyserver ha.pool.sks-keyservers.net --recv-keys "$key" ; \
done \
&& curl -SLO "http://resin-packages.s3.amazonaws.com/node/v$NODE_VERSION/node-v$<API key>.tar.gz" \
&& echo "<SHA256-like> node-v$<API key>.tar.gz" | sha256sum -c - \
&& tar -xzf "node-v$<API key>.tar.gz" -C /usr/local --strip-components=1 \
&& rm "node-v$<API key>.tar.gz" \
&& curl -fSLO --compressed "https://yarnpkg.com/downloads/$YARN_VERSION/yarn-v$YARN_VERSION.tar.gz" \
&& curl -fSLO --compressed "https://yarnpkg.com/downloads/$YARN_VERSION/yarn-v$YARN_VERSION.tar.gz.asc" \
&& gpg --batch --verify yarn-v$YARN_VERSION.tar.gz.asc yarn-v$YARN_VERSION.tar.gz \
&& mkdir -p /opt/yarn \
&& tar -xzf yarn-v$YARN_VERSION.tar.gz -C /opt/yarn --strip-components=1 \
&& ln -s /opt/yarn/bin/yarn /usr/local/bin/yarn \
&& ln -s /opt/yarn/bin/yarn /usr/local/bin/yarnpkg \
&& rm yarn-v$YARN_VERSION.tar.gz.asc yarn-v$YARN_VERSION.tar.gz \
&& npm config set unsafe-perm true -g --unsafe-perm \
|
package com.gentics.mesh.changelog.changes;
import static com.gentics.mesh.core.data.relationship.GraphRelationships.<API key>;
import com.gentics.mesh.changelog.AbstractChange;
import com.tinkerpop.blueprints.Direction;
/**
* Changelog entry which removed the schema version edges with properties
*/
public class <API key> extends AbstractChange {
@Override
public String getUuid() {
return "<API key>";
}
@Override
public String getName() {
return "<API key>";
}
@Override
public String getDescription() {
return "Replaces edges from node content to schema versions with properties.";
}
@Override
public void applyInTx() {
replaceSingleEdge("<API key>", Direction.OUT, "<API key>", <API key>);
}
}
|
package sl.hr_client;
import android.app.Application;
import android.test.ApplicationTestCase;
public class ApplicationTest extends ApplicationTestCase<Application> {
public ApplicationTest() {
super(Application.class);
}
}
|
using System;
#if Q8
using QuantumType = System.Byte;
#elif Q16
using QuantumType = System.UInt16;
#elif Q16HDRI
using QuantumType = System.Single;
#else
#error Not implemented!
#endif
namespace ImageMagick
{
<summary>
Class that represents a HSV color.
</summary>
public sealed class ColorHSV : ColorBase
{
<summary>
Initializes a new instance of the <see cref="ColorHSV"/> class.
</summary>
<param name="hue">Hue component value of this color.</param>
<param name="saturation">Saturation component value of this color.</param>
<param name="value">Value component value of this color.</param>
public ColorHSV(double hue, double saturation, double value)
: base(new MagickColor(0, 0, 0))
{
Hue = hue;
Saturation = saturation;
Value = value;
}
private ColorHSV(IMagickColor<QuantumType> color)
: base(color)
{
Initialize(color.R, color.G, color.B);
}
<summary>
Gets or sets the hue component value of this color.
</summary>
public double Hue { get; set; }
<summary>
Gets or sets the saturation component value of this color.
</summary>
public double Saturation { get; set; }
<summary>
Gets or sets the value component value of this color.
</summary>
public double Value { get; set; }
<summary>
Converts the specified <see cref="MagickColor"/> to an instance of this type.
</summary>
<param name="color">The color to use.</param>
<returns>A <see cref="ColorHSV"/> instance.</returns>
public static implicit operator ColorHSV?(MagickColor color)
=> FromMagickColor(color);
<summary>
Converts the specified <see cref="IMagickColor{QuantumType}"/> to an instance of this type.
</summary>
<param name="color">The color to use.</param>
<returns>A <see cref="ColorHSV"/> instance.</returns>
public static ColorHSV? FromMagickColor(IMagickColor<QuantumType> color)
{
if (color == null)
return null;
return new ColorHSV(color);
}
<summary>
Performs a hue shift with the specified degrees.
</summary>
<param name="degrees">The degrees.</param>
public void HueShift(double degrees)
{
Hue += degrees / 360.0;
while (Hue >= 1.0)
Hue -= 1.0;
while (Hue < 0.0)
Hue += 1.0;
}
<summary>
Updates the color value in an inherited class.
</summary>
protected override void UpdateColor()
{
if (Math.Abs(Saturation) < double.Epsilon)
{
Color.R = Color.G = Color.B = Quantum.ScaleToQuantum(Value);
return;
}
var h = 6.0 * (Hue - Math.Floor(Hue));
var f = h - Math.Floor(h);
var p = Value * (1.0 - Saturation);
var q = Value * (1.0 - (Saturation * f));
var t = Value * (1.0 - (Saturation * (1.0 - f)));
switch ((int)h)
{
case 0:
default:
Color.R = Quantum.ScaleToQuantum(Value);
Color.G = Quantum.ScaleToQuantum(t);
Color.B = Quantum.ScaleToQuantum(p);
break;
case 1:
Color.R = Quantum.ScaleToQuantum(q);
Color.G = Quantum.ScaleToQuantum(Value);
Color.B = Quantum.ScaleToQuantum(p);
break;
case 2:
Color.R = Quantum.ScaleToQuantum(p);
Color.G = Quantum.ScaleToQuantum(Value);
Color.B = Quantum.ScaleToQuantum(t);
break;
case 3:
Color.R = Quantum.ScaleToQuantum(p);
Color.G = Quantum.ScaleToQuantum(q);
Color.B = Quantum.ScaleToQuantum(Value);
break;
case 4:
Color.R = Quantum.ScaleToQuantum(t);
Color.G = Quantum.ScaleToQuantum(p);
Color.B = Quantum.ScaleToQuantum(Value);
break;
case 5:
Color.R = Quantum.ScaleToQuantum(Value);
Color.G = Quantum.ScaleToQuantum(p);
Color.B = Quantum.ScaleToQuantum(q);
break;
}
}
private void Initialize(double red, double green, double blue)
{
Hue = 0.0;
Saturation = 0.0;
Value = 0.0;
var min = Math.Min(Math.Min(red, green), blue);
var max = Math.Max(Math.Max(red, green), blue);
if (Math.Abs(max) < double.Epsilon)
return;
var delta = max - min;
Saturation = delta / max;
Value = (1.0 / Quantum.Max) * max;
if (Math.Abs(delta) < double.Epsilon)
return;
if (Math.Abs(red - max) < double.Epsilon)
Hue = (green - blue) / delta;
else if (Math.Abs(green - max) < double.Epsilon)
Hue = 2.0 + ((blue - red) / delta);
else
Hue = 4.0 + ((red - green) / delta);
Hue /= 6.0;
if (Hue < 0.0)
Hue += 1.0;
}
}
}
|
package cc.mallet.util;
/**
* Static utility methods for Strings
*/
final public class Strings {
public static int commonPrefixIndex (String[] strings)
{
int prefixLen = strings[0].length();
for (int i = 1; i < strings.length; i++) {
if (strings[i].length() < prefixLen)
prefixLen = strings[i].length();
int j = 0;
if (prefixLen == 0)
return 0;
while (j < prefixLen) {
if (strings[i-1].charAt(j) != strings[i].charAt(j)) {
prefixLen = j;
break;
}
j++;
}
}
return prefixLen;
}
public static String commonPrefix (String[] strings)
{
return strings[0].substring (0, commonPrefixIndex(strings));
}
public static int count (String string, char ch)
{
int idx = -1;
int count = 0;
while ((idx = string.indexOf (ch, idx+1)) >= 0) { count++; };
return count;
}
public static double levenshteinDistance (String s, String t) {
int n = s.length();
int m = t.length();
int d[][]; // matrix
int i; // iterates through s
int j; // iterates through t
char s_i; // ith character of s
char t_j; // jth character of t
int cost; // cost
if (n == 0)
return 1.0;
if (m == 0)
return 1.0;
d = new int[n+1][m+1];
for (i = 0; i <= n; i++)
d[i][0] = i;
for (j = 0; j <= m; j++)
d[0][j] = j;
for (i = 1; i <= n; i++) {
s_i = s.charAt (i - 1);
for (j = 1; j <= m; j++) {
t_j = t.charAt (j - 1);
cost = (s_i == t_j) ? 0 : 1;
d[i][j] = minimum (d[i-1][j]+1, d[i][j-1]+1, d[i-1][j-1] + cost);
}
}
int longer = (n > m) ? n : m;
return (double)d[n][m] / longer; // Normalize to 0-1.
}
private static int minimum (int a, int b, int c) {
int mi = a;
if (b < mi) {
mi = b;
}
if (c < mi) {
mi = c;
}
return mi;
}
}
|
package org.museautomation.core.step;
import org.jetbrains.annotations.*;
import org.museautomation.core.*;
import org.museautomation.core.context.*;
import org.museautomation.core.step.descriptor.*;
import org.museautomation.core.steptask.*;
import org.museautomation.core.values.*;
import org.museautomation.core.values.descriptor.*;
import java.util.*;
@MuseTypeId("callmacro")
@MuseStepName("Macro")
@<API key>("call macro {id}")
@MuseStepIcon("glyph:FontAwesome:EXTERNAL_LINK")
@MuseStepTypeGroup("Structure")
@<API key>("The 'id' source is resolved to a string and used to find the macro in the project. The steps within the macro are then executed as children of the call-macro step, within the same variable scope as the parent. This means that steps within the macro have access to the same variables as the caller.")
@<API key>(displayName = "Macro name", description = "The name (resource id) of the macro to call", type = SubsourceDescriptor.Type.Named, name = CallMacroStep.ID_PARAM)
public class CallMacroStep extends ScopedGroup
{
@SuppressWarnings("unused") // called via reflection
public CallMacroStep(StepConfiguration config, MuseProject project)
{
super(config, project);
_config = config;
_project = project;
}
@Override
protected <API key> <API key>(<API key> context) throws MuseExecutionError
{
String id = getStepsId(context);
ContainsStep resource = _project.getResourceStorage().getResource(id, ContainsStep.class);
if (resource == null)
throw new StepExecutionError("unable to locate project resource, id=" + id);
StepConfiguration step = resource.getStep();
List<StepConfiguration> steps;
if (step.getChildren() != null && step.getChildren().size() > 0)
steps = step.getChildren();
else
{
steps = new ArrayList<>();
steps.add(step);
}
context.getStepLocator().loadSteps(steps);
context.raiseEvent(<API key>.create(_config, steps));
return new <API key>(context.getParent(), steps, <API key>(), this);
}
/**
* Get the id of the project resource that contains the steps that should be run.
*/
@NotNull
@SuppressWarnings("WeakerAccess")
protected String getStepsId(<API key> context) throws MuseExecutionError
{
MuseValueSource id_source = getValueSource(_config, ID_PARAM, true, context.getProject());
return BaseValueSource.getValue(id_source, context, false, String.class);
}
@Override
protected boolean <API key>()
{
return false;
}
protected MuseProject _project;
private StepConfiguration _config;
public final static String ID_PARAM = "id";
public final static String TYPE_ID = CallMacroStep.class.getAnnotation(MuseTypeId.class).value();
}
|
package com.intellij.openapi.diff.impl.patch.formove;
import com.intellij.openapi.application.ApplicationManager;
import com.intellij.openapi.diff.impl.patch.FilePatch;
import com.intellij.openapi.diff.impl.patch.TextFilePatch;
import com.intellij.openapi.diff.impl.patch.apply.ApplyFilePatchBase;
import com.intellij.openapi.diff.impl.patch.apply.<API key>;
import com.intellij.openapi.fileTypes.FileType;
import com.intellij.openapi.fileTypes.FileTypes;
import com.intellij.openapi.fileTypes.ex.FileTypeChooser;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.util.Comparing;
import com.intellij.openapi.util.ThrowableComputable;
import com.intellij.openapi.util.io.FileUtil;
import com.intellij.openapi.util.text.StringUtil;
import com.intellij.openapi.vcs.*;
import com.intellij.openapi.vcs.changes.patch.<API key>;
import com.intellij.openapi.vfs.VfsUtil;
import com.intellij.openapi.vfs.VfsUtilCore;
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.util.containers.ContainerUtil;
import com.intellij.vcsUtil.VcsUtil;
import org.jetbrains.annotations.CalledInAwt;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.io.File;
import java.io.IOException;
import java.util.*;
public class PathsVerifier {
private final Project myProject;
private final VirtualFile myBaseDirectory;
private final List<FilePatch> myPatches;
// temp
private final Map<VirtualFile, MovedFileData> myMovedFiles;
private final List<FilePath> myBeforePaths;
private final List<VirtualFile> <API key>;
// out
private final List<PatchAndFile> myTextPatches;
private final List<PatchAndFile> myBinaryPatches;
@NotNull private final List<VirtualFile> myWritableFiles;
private final <API key> myVcsManager;
private final List<FilePatch> mySkipped;
private <API key> <API key>;
private final List<FilePath> myAddedPaths;
private final List<FilePath> myDeletedPaths;
private boolean <API key>;
public PathsVerifier(@NotNull Project project,
@NotNull VirtualFile baseDirectory,
@NotNull List<FilePatch> patches) {
myProject = project;
myBaseDirectory = baseDirectory;
myPatches = patches;
myMovedFiles = new HashMap<>();
myBeforePaths = new ArrayList<>();
<API key> = new ArrayList<>();
myTextPatches = new ArrayList<>();
myBinaryPatches = new ArrayList<>();
myWritableFiles = new ArrayList<>();
myVcsManager = <API key>.getInstance(myProject);
mySkipped = new ArrayList<>();
myAddedPaths = new ArrayList<>();
myDeletedPaths = new ArrayList<>();
}
// those to be moved to CL: target + created dirs
public List<FilePath> getDirectlyAffected() {
final List<FilePath> affected = new ArrayList<>();
addAllFilePath(<API key>, affected);
addAllFilePath(myWritableFiles, affected);
affected.addAll(myBeforePaths);
return affected;
}
// old parents of moved files
public List<VirtualFile> getAllAffected() {
final List<VirtualFile> affected = new ArrayList<>();
affected.addAll(<API key>);
affected.addAll(myWritableFiles);
// after files' parent
for (VirtualFile file : myMovedFiles.keySet()) {
final VirtualFile parent = file.getParent();
if (parent != null) {
affected.add(parent);
}
}
// before..
for (FilePath path : myBeforePaths) {
final FilePath parent = path.getParentPath();
if (parent != null) {
affected.add(parent.getVirtualFile());
}
}
return affected;
}
private static void addAllFilePath(final Collection<VirtualFile> files, final Collection<FilePath> paths) {
for (VirtualFile file : files) {
paths.add(VcsUtil.getFilePath(file));
}
}
@CalledInAwt
public List<FilePatch> <API key>() {
List<FilePatch> failedToApply = ContainerUtil.newArrayList();
<API key> = new <API key>(myProject);
for (FilePatch patch : myPatches) {
final CheckPath checker = getChecker(patch);
if (!checker.canBeApplied(<API key>)) {
revert(checker.getErrorMessage());
failedToApply.add(patch);
}
}
final Collection<FilePatch> skipped = <API key>.doDelayed();
mySkipped.addAll(skipped);
myPatches.removeAll(skipped);
myPatches.removeAll(failedToApply);
return failedToApply;
}
public List<FilePatch> getSkipped() {
return mySkipped;
}
public List<FilePatch> execute() {
List<FilePatch> failedPatches = ContainerUtil.newArrayList();
try {
final List<CheckPath> checkers = new ArrayList<>(myPatches.size());
for (FilePatch patch : myPatches) {
final CheckPath checker = getChecker(patch);
checkers.add(checker);
}
for (CheckPath checker : checkers) {
if (!checker.check()) {
failedPatches.add(checker.getPatch());
revert(checker.getErrorMessage());
}
}
}
catch (IOException e) {
revert(e.getMessage());
}
myPatches.removeAll(failedPatches);
return failedPatches;
}
private CheckPath getChecker(final FilePatch patch) {
final String beforeFileName = patch.getBeforeName();
final String afterFileName = patch.getAfterName();
if (beforeFileName == null || patch.isNewFile()) {
return new CheckAdded(patch);
}
else if (afterFileName == null || patch.isDeletedFile()) {
return new CheckDeleted(patch);
}
else if (!beforeFileName.equals(afterFileName)) {
return new CheckMoved(patch);
}
else {
return new CheckModified(patch);
}
}
public Collection<FilePath> getToBeAdded() {
return myAddedPaths;
}
public Collection<FilePath> getToBeDeleted() {
return myDeletedPaths;
}
@NotNull
public Collection<FilePatch> <API key>() {
List<PatchAndFile> failedTextPatches =
ContainerUtil.findAll(myTextPatches, textPatch -> !isFileTypeOk(textPatch.getFile()));
myTextPatches.removeAll(failedTextPatches);
return ContainerUtil.map(failedTextPatches, patchInfo -> patchInfo.getApplyPatch().getPatch());
}
private boolean isFileTypeOk(@NotNull VirtualFile file) {
if (file.isDirectory()) {
PatchApplier
.showError(myProject, "Cannot apply content for " + file.getPresentableName() + " file from patch because it is directory.");
return false;
}
FileType fileType = file.getFileType();
if (fileType == FileTypes.UNKNOWN) {
fileType = FileTypeChooser.associateFileType(file.getName());
if (fileType == null) {
PatchApplier
.showError(myProject, "Cannot apply content for " + file.getPresentableName() + " file from patch because its type not defined.");
return false;
}
}
if (fileType.isBinary()) {
PatchApplier.showError(myProject, "Cannot apply file " + file.getPresentableName() + " from patch because it is binary.");
return false;
}
return true;
}
private class CheckModified extends CheckDeleted {
private CheckModified(final FilePatch path) {
super(path);
}
}
private class CheckDeleted extends CheckPath {
protected CheckDeleted(final FilePatch path) {
super(path);
}
@Override
protected boolean precheck(final VirtualFile beforeFile, final VirtualFile afterFile, <API key> context) {
if (beforeFile == null) {
context.addSkip(getMappedFilePath(myBeforeName), myPatch);
}
return true;
}
@Override
protected boolean check() {
final VirtualFile beforeFile = getMappedFile(myBeforeName);
if (! checkExistsAndValid(beforeFile, myBeforeName)) {
return false;
}
addPatch(myPatch, beforeFile);
FilePath filePath = VcsUtil.getFilePath(beforeFile.getParent(), beforeFile.getName(), beforeFile.isDirectory());
if (myPatch.isDeletedFile() || myPatch.getAfterName() == null) {
myDeletedPaths.add(filePath);
}
myBeforePaths.add(filePath);
return true;
}
}
private class CheckAdded extends CheckPath {
private CheckAdded(final FilePatch path) {
super(path);
}
@Override
protected boolean precheck(final VirtualFile beforeFile, final VirtualFile afterFile, <API key> context) {
if (afterFile != null) {
context.addOverrideExisting(myPatch, VcsUtil.getFilePath(afterFile));
}
return true;
}
@Override
public boolean check() throws IOException {
final String[] pieces = <API key>.split(myAfterName);
final VirtualFile parent = <API key>(pieces);
if (parent == null) {
setErrorMessage(fileNotFoundMessage(myAfterName));
return false;
}
String name = pieces[pieces.length - 1];
File afterFile = new File(parent.getPath(), name);
//if user already accepted overwriting, we shouldn't have created a new one
final VirtualFile file = <API key>.getOverridenPaths().contains(VcsUtil.getFilePath(afterFile))
? parent.findChild(name)
: createFile(parent, name);
if (file == null) {
setErrorMessage(fileNotFoundMessage(myAfterName));
return false;
}
myAddedPaths.add(VcsUtil.getFilePath(file));
if (! checkExistsAndValid(file, myAfterName)) {
return false;
}
addPatch(myPatch, file);
return true;
}
}
private class CheckMoved extends CheckPath {
private CheckMoved(final FilePatch path) {
super(path);
}
// before exists; after does not exist
@Override
protected boolean precheck(final VirtualFile beforeFile, final VirtualFile afterFile, final <API key> context) {
if (beforeFile == null) {
setErrorMessage(fileNotFoundMessage(myBeforeName));
} else if (afterFile != null) {
setErrorMessage(fileAlreadyExists(afterFile.getPath()));
}
return beforeFile != null && afterFile == null;
}
@Override
public boolean check() throws IOException {
final String[] pieces = <API key>.split(myAfterName);
final VirtualFile afterFileParent = <API key>(pieces);
if (afterFileParent == null) {
setErrorMessage(fileNotFoundMessage(myAfterName));
return false;
}
final VirtualFile beforeFile = getMappedFile(myBeforeName);
if (! checkExistsAndValid(beforeFile, myBeforeName)) {
return false;
}
assert beforeFile != null; // if beforeFile is null then checkExist returned false;
myMovedFiles.put(beforeFile, new MovedFileData(afterFileParent, beforeFile, myPatch.getAfterFileName()));
addPatch(myPatch, beforeFile);
return true;
}
}
private abstract class CheckPath {
protected final String myBeforeName;
protected final String myAfterName;
protected final FilePatch myPatch;
private String myErrorMessage;
CheckPath(final FilePatch path) {
myPatch = path;
myBeforeName = path.getBeforeName();
myAfterName = path.getAfterName();
}
public String getErrorMessage() {
return myErrorMessage;
}
public void setErrorMessage(final String errorMessage) {
myErrorMessage = errorMessage;
}
public boolean canBeApplied(<API key> context) {
final VirtualFile beforeFile = getMappedFile(myBeforeName);
final VirtualFile afterFile = getMappedFile(myAfterName);
return precheck(beforeFile, afterFile, context);
}
protected abstract boolean precheck(final VirtualFile beforeFile,
final VirtualFile afterFile,
<API key> context);
protected abstract boolean check() throws IOException;
protected boolean checkExistsAndValid(final VirtualFile file, final String name) {
if (file == null) {
setErrorMessage(fileNotFoundMessage(name));
return false;
}
return <API key>(file, name);
}
protected boolean <API key>(final VirtualFile file, final String name) {
if (ApplicationManager.getApplication().isUnitTestMode() && <API key>) return true;
// security check to avoid overwriting system files with a patch
if (file == null || !inContent(file) || myVcsManager.getVcsRootFor(file) == null) {
setErrorMessage("File to patch found outside content root: " + name);
return false;
}
return true;
}
@Nullable
protected VirtualFile getMappedFile(String path) {
return PathMerger.getFile(myBaseDirectory, path);
}
protected FilePath getMappedFilePath(String path) {
return PathMerger.getFile(VcsUtil.getFilePath(myBaseDirectory), path);
}
private boolean inContent(VirtualFile file) {
return myVcsManager.isFileInContent(file);
}
public FilePatch getPatch() {
return myPatch;
}
}
private void addPatch(final FilePatch patch, final VirtualFile file) {
if (patch instanceof TextFilePatch) {
myTextPatches.add(new PatchAndFile(file, <API key>.create((TextFilePatch)patch)));
}
else {
myBinaryPatches.add(new PatchAndFile(file, <API key>.createGeneral(patch)));
}
myWritableFiles.add(file);
}
private static String fileNotFoundMessage(final String path) {
return VcsBundle.message("cannot.find.file.to.patch", path);
}
private static String fileAlreadyExists(final String path) {
return VcsBundle.message("cannot.apply.file.already.exists", path);
}
private void revert(final String errorMessage) {
PatchApplier.showError(myProject, errorMessage);
// move back
/*for (MovedFileData movedFile : myMovedFiles) {
try {
final VirtualFile current = movedFile.getCurrent();
final VirtualFile newParent = current.getParent();
final VirtualFile file;
if (! Comparing.equal(newParent, movedFile.getOldParent())) {
file = moveFile(current, movedFile.getOldParent());
} else {
file = current;
}
if (! Comparing.equal(current.getName(), movedFile.getOldName())) {
file.rename(PatchApplier.class, movedFile.getOldName());
}
}
catch (IOException e) {
// ignore: revert as much as possible
}
}
// go back
ApplicationManager.getApplication().runWriteAction(new Runnable() {
public void run() {
for (int i = <API key>.size() - 1; i >= 0; -- i) {
final VirtualFile file = <API key>.get(i);
try {
file.delete(PatchApplier.class);
}
catch (IOException e) {
// ignore
}
}
}
});
myBinaryPatches.clear();
myTextPatches.clear();
myWritableFiles.clear();*/
}
private static VirtualFile createFile(final VirtualFile parent, final String name) throws IOException {
return parent.createChildData(PatchApplier.class, name);
/*final Ref<IOException> ioExceptionRef = new Ref<IOException>();
final Ref<VirtualFile> result = new Ref<VirtualFile>();
ApplicationManager.getApplication().runWriteAction(new Runnable() {
public void run() {
try {
result.set(parent.createChildData(PatchApplier.class, name));
}
catch (IOException e) {
ioExceptionRef.set(e);
}
}
});
if (! ioExceptionRef.isNull()) {
throw ioExceptionRef.get();
}
return result.get();*/
}
private static VirtualFile moveFile(final VirtualFile file, final VirtualFile newParent) throws IOException {
file.move(FilePatch.class, newParent);
return file;
/*final Ref<IOException> ioExceptionRef = new Ref<IOException>();
ApplicationManager.getApplication().runWriteAction(new Runnable() {
public void run() {
try {
file.move(FilePatch.class, newParent);
}
catch (IOException e) {
ioExceptionRef.set(e);
}
}
});
if (! ioExceptionRef.isNull()) {
throw ioExceptionRef.get();
}
return file;*/
}
@Nullable
private VirtualFile <API key>(final String[] pieces) throws IOException {
VirtualFile child = myBaseDirectory;
final int size = pieces.length - 1;
for (int i = 0; i < size; i++) {
final String piece = pieces[i];
if (StringUtil.isEmptyOrSpaces(piece)) {
continue;
}
if ("..".equals(piece)) {
child = child.getParent();
continue;
}
VirtualFile nextChild = child.findChild(piece);
if (nextChild == null) {
nextChild = VfsUtil.createDirectories(child.getPath() + '/' + piece);
<API key>.add(nextChild);
}
child = nextChild;
}
return child;
}
public List<PatchAndFile> getTextPatches() {
return myTextPatches;
}
public List<PatchAndFile> getBinaryPatches() {
return myBinaryPatches;
}
@NotNull
public List<VirtualFile> getWritableFiles() {
return myWritableFiles;
}
public void doMoveIfNeeded(final VirtualFile file) throws IOException {
final MovedFileData movedFile = myMovedFiles.get(file);
if (movedFile != null) {
myBeforePaths.add(VcsUtil.getFilePath(file));
ApplicationManager.getApplication().runWriteAction(new ThrowableComputable<VirtualFile, IOException>() {
@Override
public VirtualFile compute() throws IOException {
return movedFile.doMove();
}
});
}
}
private static class MovedFileData {
private final VirtualFile myNewParent;
private final VirtualFile myCurrent;
private final String myNewName;
private MovedFileData(@NotNull final VirtualFile newParent, @NotNull final VirtualFile current, @NotNull final String newName) {
myNewParent = newParent;
myCurrent = current;
myNewName = newName;
}
public VirtualFile getCurrent() {
return myCurrent;
}
public VirtualFile getNewParent() {
return myNewParent;
}
public String getNewName() {
return myNewName;
}
public VirtualFile doMove() throws IOException {
final VirtualFile oldParent = myCurrent.getParent();
boolean needRename = !Comparing.equal(myCurrent.getName(), myNewName);
boolean needMove = !myNewParent.equals(oldParent);
if (needRename) {
if (needMove) {
File oldParentFile = VfsUtilCore.virtualToIoFile(oldParent);
File <API key> = new File(oldParentFile, myNewName);
if (<API key>.exists() && myCurrent.exists()) {
// if there is a conflict during first rename we have to rename to third name, then move, then rename to final target
<API key>(oldParentFile);
return myCurrent;
}
}
myCurrent.rename(PatchApplier.class, myNewName);
}
if (needMove) {
myCurrent.move(PatchApplier.class, myNewParent);
}
return myCurrent;
}
private void <API key>(@NotNull File oldParent) throws IOException {
File <API key> = FileUtil.createTempFile(oldParent, "tempFileToMove", null, false);
File newParentFile = VfsUtilCore.virtualToIoFile(myNewParent);
File destFile = new File(newParentFile, <API key>.getName());
while (destFile.exists()) {
destFile = new File(newParentFile,
FileUtil.createTempFile(oldParent, FileUtil.<API key>(destFile.getName()), null, false)
.getName());
}
myCurrent.rename(PatchApplier.class, destFile.getName());
myCurrent.move(PatchApplier.class, myNewParent);
myCurrent.rename(PatchApplier.class, myNewName);
}
}
private static class <API key> {
private final Map<FilePath, FilePatch> mySkipDeleted;
private final Map<FilePath, FilePatch> myOverrideExisting;
private final List<FilePath> myOverridenPaths;
private final Project myProject;
private <API key>(final Project project) {
myProject = project;
myOverrideExisting = new HashMap<>();
mySkipDeleted = new HashMap<>();
myOverridenPaths = new LinkedList<>();
}
public void addSkip(final FilePath path, final FilePatch filePatch) {
mySkipDeleted.put(path, filePatch);
}
public void addOverrideExisting(final FilePatch patch, final FilePath filePath) {
if (! myOverrideExisting.containsKey(filePath)) {
myOverrideExisting.put(filePath, patch);
}
}
// returns those to be skipped
public Collection<FilePatch> doDelayed() {
final List<FilePatch> result = new LinkedList<>();
if (! myOverrideExisting.isEmpty()) {
final String title = "Overwrite Existing Files";
List<FilePath> files = new ArrayList<>(myOverrideExisting.keySet());
Collection<FilePath> selected = AbstractVcsHelper.getInstance(myProject).<API key>(
files, title,
"\nThe following files should be created by patch, but they already exist.\nDo you want to overwrite them?\n", title,
"The following file should be created by patch, but it already exists.\nDo you want to overwrite it?\n{0}",
<API key>.<API key>,
"Overwrite", "Cancel");
if (selected != null) {
for (FilePath path : selected) {
myOverrideExisting.remove(path);
}
}
result.addAll(myOverrideExisting.values());
if (selected != null) {
myOverridenPaths.addAll(selected);
}
}
result.addAll(mySkipDeleted.values());
return result;
}
public List<FilePath> getOverridenPaths() {
return myOverridenPaths;
}
public Collection<FilePath> <API key>() {
return mySkipDeleted.keySet();
}
}
public void <API key>(boolean <API key>) {
<API key> = <API key>;
}
public static class PatchAndFile {
private final VirtualFile myFile;
private final ApplyFilePatchBase<?> myPatch;
public PatchAndFile(VirtualFile file, ApplyFilePatchBase<?> patch) {
myFile = file;
myPatch = patch;
}
public VirtualFile getFile() {
return myFile;
}
public ApplyFilePatchBase<?> getApplyPatch() {
return myPatch;
}
}
}
|
package com.therabbitmage.android.beacon.network;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URISyntaxException;
import org.apache.http.Header;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.message.BasicHeader;
import android.net.Uri;
import android.util.Log;
import com.therabbitmage.android.beacon.entities.google.urlshortener.Url;
public final class URLShortenerAPI {
private static final String TAG = URLShortenerAPI.class.getSimpleName();
private static final String BASE_URL = "https:
public static NetworkResponse urlShorten(String url) throws IOException, URISyntaxException{
android.net.Uri.Builder uriBuilder = Uri.parse(BASE_URL).buildUpon();
String uri = uriBuilder.build().toString();
Header[] headers = new Header[1];
headers[0] = new BasicHeader(ApacheNetworkUtils.HEADER_CONTENT_TYPE, ApacheNetworkUtils.TYPE_JSON);
ApacheNetworkUtils.getAndroidInstance(ApacheNetworkUtils.sUserAgent, false);
HttpResponse response = ApacheNetworkUtils.post(
uri,
ApacheNetworkUtils.<API key>(),
new Url(url).toJson());
ApacheNetworkUtils.<API key>(response.getAllHeaders());
ApacheNetworkUtils.toStringStatusLine(response.getStatusLine());
HttpEntity entity = response.getEntity();
NetworkResponse networkResponse = new NetworkResponse();
if(response.getStatusLine().getStatusCode() == HttpStatus.SC_OK){
networkResponse.setError(0);
BufferedReader br = new BufferedReader(new InputStreamReader(entity.getContent()));
StringBuilder stringBuilder = new StringBuilder();
String output = new String();
while((output = br.readLine()) != null){
stringBuilder.append(output);
}
br.close();
Log.i(TAG, "Body: " + stringBuilder.toString());
networkResponse.setUrl(Url.fromJson(stringBuilder.toString()));
} else {
networkResponse.setError(1);
}
return networkResponse;
}
}
|
#include "common/common/version.h"
std::string VersionInfo::version() {
return fmt::format("{}/{}", GIT_SHA.substr(0, 6),
#ifdef NDEBUG
"RELEASE"
#else
"DEBUG"
#endif
);
}
|
<?php
/*!
* @mainpage Configuration
*
* @section intro Introduction
*
* You can create file <b>application/config.php</b> for configuration.
*
* @section intro Configuration items
*
* @subsection encryptor Encrypt
* For NpFactory::getEncryptor, $_CONFIG['encryptor']
* @param mode encrypt mode, support aes, 3des; default aes
* @param password password, length limit: min 7, max 32 for aes and 16 for 3des
* @param timeout seconds for expire time, default 0 (forever)
*
* @subsection database Database
* For NpFactory::getDatabase, $_CONFIG['database']
* @param type database type for PDO, default mysql
* @param host host or ip address for connect, default localhost
* @param port port for connect, default 3306
* @param user username for connect, default root
* @param passwd password for connect, default empty
* @param dbname database name for connect, default mysql
* @param charset charset for connect, default utf8
* @param persistent persistent for connect, default true
*
* For NpFactory::getExtraDatabase, $_CONFIG's key is 'database-' append extra name.
*
* @subsection cache Key-Value Cache
* For NpFactory::getCache, $_CONFIG['cache']
* @param type cache type, support memcache,memcached,redis; default memcache
* @param host host or ip address for connect, default localhost
* @param port port for connect, default 11211
* @param prefix prefix append for keys, default empty
* @param timeout seconds for expire time, default 0 (forever)
*
* For NpFactory::getExtraCache, $_CONFIG's key is 'cache-' append extra name.
*
* @subsection system Environment
* For Framework environment, $_CONFIG['system']
* @param quiet error reporting level switch, true is E_ERROR | E_PARSE, flase is E_ALL ^ E_NOTICE, default false
* @param timeZone date's default time zone, default UTC
*/
//! The class for configs
class NpConfig {
private static $configs;
private static function load()
{
if(!defined('NP_CONF_PATH'))
define('NP_CONF_PATH', NP_APP_PATH);
$_CONFIG=array();
// encryptor
$config=array();
$config['mode'] = 'aes'; // as: aes(32), 3des(16)
$config['password'] = '<API key>';
$config['timeout'] = 0; // seconds
$_CONFIG['encryptor']=$config;
// database
$config=array();
$config['type'] = 'mysql';
$config['host'] = 'localhost';
$config['port'] = 3306;
$config['user'] = 'root';
$config['passwd'] = '';
$config['dbname'] = 'mysql';
$config['charset'] = 'utf8';
$config['persistent'] = true;
$_CONFIG['database']=$config;
// cache
$config=array();
$config['type'] = 'memcache';
$config['host'] = 'localhost';
$config['port'] = 11211;
$config['prefix'] = '';
$config['timeout'] = 0; // seconds
$_CONFIG['cache']=$config;
// system
$config=array();
$config['quiet'] = false;
$config['timeZone'] = 'UTC';
$_CONFIG['system']=$config;
// load application config
@include(NP_CONF_PATH.'config.php');
// apply values to setting
if($_CONFIG['system']['quiet']===true)
error_reporting(E_ERROR | E_PARSE);
else
error_reporting(E_ALL ^ E_NOTICE);
<API key>($_CONFIG['system']['timeZone']);
self::$configs=$_CONFIG;
}
//! Get a config item object
public static function get($key)
{
if(self::$configs===null)
self::load();
if(!isset(self::$configs[$key]))
throw new Exception('Not found config item:'.$key);
return self::$configs[$key];
}
}
?>
|
/* $Header: /cvs/maptools/cvsroot/libtiff/contrib/pds/tif_pdsdirread.c,v 1.2 2003/11/17 15:09:39 dron Exp $ */
/*
* TIFF Library.
*
* These routines written by Conrad J. Poelman on a single late-night of
* March 20-21, 1996.
*
* The entire purpose of this file is to provide a single external function,
* <API key>(). This function is intended for use in reading a
* private subdirectory from a TIFF file into a private structure. The
* actual writing of data into the structure is handled by the setFieldFn(),
* which is passed to <API key>() as a parameter. The idea is to
* enable any application wishing to store private subdirectories to do so
* easily using this function, without modifying the TIFF library.
*
* The astute observer will notice that only two functions are at all different
* from the original tif_dirread.c file: <API key>() and
* <API key>(). All the other stuff that makes this file so huge
* is only necessary because all of those functions are declared static in
* tif_dirread.c, so we have to totally duplicate them in order to use them.
*
* Oh, also note the bug fix in TIFFFetchFloat().
*
*/
#include "tiffiop.h"
#define IGNORE 0 /* tag placeholder used below */
#if HAVE_IEEEFP
#define <API key>(tif, n, fp)
#define <API key>(tif, n, dp)
#else
extern void <API key>(TIFF*, uint32, float*);
extern void <API key>(TIFF*, uint32, double*);
#endif
static void <API key>(TIFF*, TIFFDirEntry*, uint16);
static void MissingRequired(TIFF*, const char*);
static int CheckDirCount(TIFF*, TIFFDirEntry*, uint32);
static tsize_t TIFFFetchData(TIFF*, TIFFDirEntry*, char*);
static tsize_t TIFFFetchString(TIFF*, TIFFDirEntry*, char*);
static float TIFFFetchRational(TIFF*, TIFFDirEntry*);
static int <API key>(TIFF*, TIFFDirEntry*, const TIFFFieldInfo*,
int (*getFieldFn)(TIFF *tif,ttag_t tag,...));
static int <API key>(TIFF*, TIFFDirEntry*, int*);
static int <API key>(TIFF*, TIFFDirEntry*, double*);
static int TIFFFetchShortArray(TIFF*, TIFFDirEntry*, uint16*);
static int TIFFFetchStripThing(TIFF*, TIFFDirEntry*, long, uint32**);
static int <API key>(TIFF*, TIFFDirEntry*);
static int <API key>(TIFF*, TIFFDirEntry*);
static float TIFFFetchFloat(TIFF*, TIFFDirEntry*);
static int TIFFFetchFloatArray(TIFF*, TIFFDirEntry*, float*);
static int <API key>(TIFF*, TIFFDirEntry*, double*);
static int TIFFFetchAnyArray(TIFF*, TIFFDirEntry*, double*);
static int TIFFFetchShortPair(TIFF*, TIFFDirEntry*);
#if STRIPCHOP_SUPPORT
static void <API key>(TIFF*);
#endif
static char *
CheckMalloc(TIFF* tif, tsize_t n, const char* what)
{
char *cp = (char*)_TIFFmalloc(n);
if (cp == NULL)
TIFFError(tif->tif_name, "No space %s", what);
return (cp);
}
/* Just as was done with <API key>(), here we implement
<API key>() which takes an offset into the TIFF file,
a TIFFFieldInfo structure specifying the types of the various tags,
and a function to use to set individual tags when they are encountered.
The data is read from the file, translated using the TIFF library's
built-in machine-independent conversion functions, and filled into
private subdirectory structure.
This code was written by copying the original TIFFReadDirectory() function
from tif_dirread.c and paring it down to what is needed for this.
It is the caller's responsibility to allocate and initialize the internal
structure that setFieldFn() will be writing into. If this function is being
called more than once before closing the file, the caller also must be
careful to free data in the structure before re-initializing.
It is also the caller's responsibility to verify the presence of
any required fields after reading the directory in.
*/
int
<API key>(TIFF* tif, toff_t pdir_offset,
TIFFFieldInfo *field_info,
int (*setFieldFn)(TIFF *tif, ttag_t tag, ...))
{
register TIFFDirEntry* dp;
register int n;
register TIFFDirectory* td;
TIFFDirEntry* dir;
int iv;
long v;
double dv;
const TIFFFieldInfo* fip;
int fix;
uint16 dircount;
uint32 nextdiroff;
char* cp;
int <API key> = 0;
/* Skipped part about checking for directories or compression data. */
if (!isMapped(tif)) {
if (!SeekOK(tif, pdir_offset)) {
TIFFError(tif->tif_name,
"Seek error accessing TIFF private subdirectory");
return (0);
}
if (!ReadOK(tif, &dircount, sizeof (uint16))) {
TIFFError(tif->tif_name,
"Can not read TIFF private subdirectory count");
return (0);
}
if (tif->tif_flags & TIFF_SWAB)
TIFFSwabShort(&dircount);
dir = (TIFFDirEntry *)CheckMalloc(tif,
dircount * sizeof (TIFFDirEntry), "to read TIFF private subdirectory");
if (dir == NULL)
return (0);
if (!ReadOK(tif, dir, dircount*sizeof (TIFFDirEntry))) {
TIFFError(tif->tif_name, "Can not read TIFF private subdirectory");
goto bad;
}
/*
* Read offset to next directory for sequential scans.
*/
(void) ReadOK(tif, &nextdiroff, sizeof (uint32));
} else {
toff_t off = pdir_offset;
if (off + sizeof (short) > tif->tif_size) {
TIFFError(tif->tif_name,
"Can not read TIFF private subdirectory count");
return (0);
} else
_TIFFmemcpy(&dircount, tif->tif_base + off, sizeof (uint16));
off += sizeof (uint16);
if (tif->tif_flags & TIFF_SWAB)
TIFFSwabShort(&dircount);
dir = (TIFFDirEntry *)CheckMalloc(tif,
dircount * sizeof (TIFFDirEntry), "to read TIFF private subdirectory");
if (dir == NULL)
return (0);
if (off + dircount*sizeof (TIFFDirEntry) > tif->tif_size) {
TIFFError(tif->tif_name, "Can not read TIFF private subdirectory");
goto bad;
} else
_TIFFmemcpy(dir, tif->tif_base + off,
dircount*sizeof (TIFFDirEntry));
off += dircount* sizeof (TIFFDirEntry);
if (off + sizeof (uint32) < tif->tif_size)
_TIFFmemcpy(&nextdiroff, tif->tif_base+off, sizeof (uint32));
}
if (tif->tif_flags & TIFF_SWAB)
TIFFSwabLong(&nextdiroff);
/*
* Setup default value and then make a pass over
* the fields to check type and tag information,
* and to extract info required to size data
* structures. A second pass is made afterwards
* to read in everthing not taken in the first pass.
*/
td = &tif->tif_dir;
for (fip = field_info, dp = dir, n = dircount;
n > 0; n
if (tif->tif_flags & TIFF_SWAB) {
<API key>(&dp->tdir_tag, 2);
TIFFSwabArrayOfLong(&dp->tdir_count, 2);
}
/*
* Find the field information entry for this tag.
*/
/*
* Silicon Beach (at least) writes unordered
* directory tags (violating the spec). Handle
* it here, but be obnoxious (maybe they'll fix it?).
*/
if (dp->tdir_tag < fip->field_tag) {
if (!<API key>) {
TIFFWarning(tif->tif_name,
"invalid TIFF private subdirectory; tags are not sorted in ascending order");
<API key> = 1;
}
fip = field_info; /* O(n^2) */
}
while (fip->field_tag && fip->field_tag < dp->tdir_tag)
fip++;
if (!fip->field_tag || fip->field_tag != dp->tdir_tag) {
TIFFWarning(tif->tif_name,
"unknown field with tag %d (0x%x) in private subdirectory ignored",
dp->tdir_tag, dp->tdir_tag);
dp->tdir_tag = IGNORE;
fip = field_info;/* restart search */
continue;
}
/*
* Null out old tags that we ignore.
*/
/* Not implemented yet, since FIELD_IGNORE is specific to
the main directories. Could pass this in too... */
if (0 /* && fip->field_bit == FIELD_IGNORE */) {
ignore:
dp->tdir_tag = IGNORE;
continue;
}
/*
* Check data type.
*/
while (dp->tdir_type != (u_short)fip->field_type) {
if (fip->field_type == TIFF_ANY) /* wildcard */
break;
fip++;
if (!fip->field_tag || fip->field_tag != dp->tdir_tag) {
TIFFWarning(tif->tif_name,
"wrong data type %d for \"%s\"; tag ignored",
dp->tdir_type, fip[-1].field_name);
goto ignore;
}
}
/*
* Check count if known in advance.
*/
if (fip->field_readcount != TIFF_VARIABLE) {
uint32 expected = (fip->field_readcount == TIFF_SPP) ?
(uint32) td->td_samplesperpixel :
(uint32) fip->field_readcount;
if (!CheckDirCount(tif, dp, expected))
goto ignore;
}
/* Now read in and process data from field. */
if (!<API key>(tif, dp, fip, setFieldFn))
goto bad;
}
if (dir)
_TIFFfree(dir);
return (1);
bad:
if (dir)
_TIFFfree(dir);
return (0);
}
static void
<API key>(TIFF* tif, TIFFDirEntry* dir, uint16 dircount)
{
register TIFFDirEntry *dp;
register TIFFDirectory *td = &tif->tif_dir;
uint16 i;
if (td->td_stripbytecount)
_TIFFfree(td->td_stripbytecount);
td->td_stripbytecount = (uint32*)
CheckMalloc(tif, td->td_nstrips * sizeof (uint32),
"for \"StripByteCounts\" array");
if (td->td_compression != COMPRESSION_NONE) {
uint32 space = (uint32)(sizeof (TIFFHeader)
+ sizeof (uint16)
+ (dircount * sizeof (TIFFDirEntry))
+ sizeof (uint32));
toff_t filesize = TIFFGetFileSize(tif);
uint16 n;
/* calculate amount of space used by indirect values */
for (dp = dir, n = dircount; n > 0; n
uint32 cc = dp->tdir_count*TIFFDataWidth(dp->tdir_type);
if (cc > sizeof (uint32))
space += cc;
}
space = (filesize - space) / td->td_samplesperpixel;
for (i = 0; i < td->td_nstrips; i++)
td->td_stripbytecount[i] = space;
/*
* This gross hack handles the case were the offset to
* the last strip is past the place where we think the strip
* should begin. Since a strip of data must be contiguous,
* it's safe to assume that we've overestimated the amount
* of data in the strip and trim this number back accordingly.
*/
i
if (td->td_stripoffset[i] + td->td_stripbytecount[i] > filesize)
td->td_stripbytecount[i] =
filesize - td->td_stripoffset[i];
} else {
uint32 rowbytes = TIFFScanlineSize(tif);
uint32 rowsperstrip = td->td_imagelength / td->td_nstrips;
for (i = 0; i < td->td_nstrips; i++)
td->td_stripbytecount[i] = rowbytes*rowsperstrip;
}
TIFFSetFieldBit(tif, <API key>);
if (!TIFFFieldSet(tif, FIELD_ROWSPERSTRIP))
td->td_rowsperstrip = td->td_imagelength;
}
static void
MissingRequired(TIFF* tif, const char* tagname)
{
TIFFError(tif->tif_name,
"TIFF directory is missing required \"%s\" field", tagname);
}
/*
* Check the count field of a directory
* entry against a known value. The caller
* is expected to skip/ignore the tag if
* there is a mismatch.
*/
static int
CheckDirCount(TIFF* tif, TIFFDirEntry* dir, uint32 count)
{
if (count != dir->tdir_count) {
TIFFWarning(tif->tif_name,
"incorrect count for field \"%s\" (%lu, expecting %lu); tag ignored",
_TIFFFieldWithTag(tif, dir->tdir_tag)->field_name,
dir->tdir_count, count);
return (0);
}
return (1);
}
/*
* Fetch a contiguous directory item.
*/
static tsize_t
TIFFFetchData(TIFF* tif, TIFFDirEntry* dir, char* cp)
{
int w = TIFFDataWidth(dir->tdir_type);
tsize_t cc = dir->tdir_count * w;
if (!isMapped(tif)) {
if (!SeekOK(tif, dir->tdir_offset))
goto bad;
if (!ReadOK(tif, cp, cc))
goto bad;
} else {
if (dir->tdir_offset + cc > tif->tif_size)
goto bad;
_TIFFmemcpy(cp, tif->tif_base + dir->tdir_offset, cc);
}
if (tif->tif_flags & TIFF_SWAB) {
switch (dir->tdir_type) {
case TIFF_SHORT:
case TIFF_SSHORT:
<API key>((uint16*) cp, dir->tdir_count);
break;
case TIFF_LONG:
case TIFF_SLONG:
case TIFF_FLOAT:
TIFFSwabArrayOfLong((uint32*) cp, dir->tdir_count);
break;
case TIFF_RATIONAL:
case TIFF_SRATIONAL:
TIFFSwabArrayOfLong((uint32*) cp, 2*dir->tdir_count);
break;
case TIFF_DOUBLE:
<API key>((double*) cp, dir->tdir_count);
break;
}
}
return (cc);
bad:
TIFFError(tif->tif_name, "Error fetching data for field \"%s\"",
_TIFFFieldWithTag(tif, dir->tdir_tag)->field_name);
return ((tsize_t) 0);
}
/*
* Fetch an ASCII item from the file.
*/
static tsize_t
TIFFFetchString(TIFF* tif, TIFFDirEntry* dir, char* cp)
{
if (dir->tdir_count <= 4) {
uint32 l = dir->tdir_offset;
if (tif->tif_flags & TIFF_SWAB)
TIFFSwabLong(&l);
_TIFFmemcpy(cp, &l, dir->tdir_count);
return (1);
}
return (TIFFFetchData(tif, dir, cp));
}
/*
* Convert numerator+denominator to float.
*/
static int
cvtRational(TIFF* tif, TIFFDirEntry* dir, uint32 num, uint32 denom, float* rv)
{
if (denom == 0) {
TIFFError(tif->tif_name,
"%s: Rational with zero denominator (num = %lu)",
_TIFFFieldWithTag(tif, dir->tdir_tag)->field_name, num);
return (0);
} else {
if (dir->tdir_type == TIFF_RATIONAL)
*rv = ((float)num / (float)denom);
else
*rv = ((float)(int32)num / (float)(int32)denom);
return (1);
}
}
/*
* Fetch a rational item from the file
* at offset off and return the value
* as a floating point number.
*/
static float
TIFFFetchRational(TIFF* tif, TIFFDirEntry* dir)
{
uint32 l[2];
float v;
return (!TIFFFetchData(tif, dir, (char *)l) ||
!cvtRational(tif, dir, l[0], l[1], &v) ? 1.0f : v);
}
/*
* Fetch a single floating point value
* from the offset field and return it
* as a native float.
*/
static float
TIFFFetchFloat(TIFF* tif, TIFFDirEntry* dir)
{
/* This appears to be a flagrant bug in the TIFF library, yet I
actually don't understand how it could have ever worked the old
way. Look at the comments in my new code and you'll understand. */
#if (0)
float v = (float)
TIFFExtractData(tif, dir->tdir_type, dir->tdir_offset);
<API key>(tif, 1, &v);
#else
float v;
/* This is a little bit tricky - if we just cast the uint32 to a float,
C will perform a numerical conversion, which is not what we want.
We want to take the actual bit pattern in the uint32 and interpret
it as a float. Thus we cast a uint32 * into a float * and then
dereference to get v. */
uint32 l = (uint32)
TIFFExtractData(tif, dir->tdir_type, dir->tdir_offset);
v = * (float *) &l;
<API key>(tif, 1, &v);
#endif
return (v);
}
/*
* Fetch an array of BYTE or SBYTE values.
*/
static int
TIFFFetchByteArray(TIFF* tif, TIFFDirEntry* dir, uint16* v)
{
if (dir->tdir_count <= 4) {
/*
* Extract data from offset field.
*/
if (tif->tif_header.tiff_magic == TIFF_BIGENDIAN) {
switch (dir->tdir_count) {
case 4: v[3] = dir->tdir_offset & 0xff;
case 3: v[2] = (dir->tdir_offset >> 8) & 0xff;
case 2: v[1] = (dir->tdir_offset >> 16) & 0xff;
case 1: v[0] = dir->tdir_offset >> 24;
}
} else {
switch (dir->tdir_count) {
case 4: v[3] = dir->tdir_offset >> 24;
case 3: v[2] = (dir->tdir_offset >> 16) & 0xff;
case 2: v[1] = (dir->tdir_offset >> 8) & 0xff;
case 1: v[0] = dir->tdir_offset & 0xff;
}
}
return (1);
} else
return (TIFFFetchData(tif, dir, (char*) v) != 0); /* XXX */
}
/*
* Fetch an array of SHORT or SSHORT values.
*/
static int
TIFFFetchShortArray(TIFF* tif, TIFFDirEntry* dir, uint16* v)
{
if (dir->tdir_count <= 2) {
if (tif->tif_header.tiff_magic == TIFF_BIGENDIAN) {
switch (dir->tdir_count) {
case 2: v[1] = dir->tdir_offset & 0xffff;
case 1: v[0] = dir->tdir_offset >> 16;
}
} else {
switch (dir->tdir_count) {
case 2: v[1] = dir->tdir_offset >> 16;
case 1: v[0] = dir->tdir_offset & 0xffff;
}
}
return (1);
} else
return (TIFFFetchData(tif, dir, (char *)v) != 0);
}
/*
* Fetch a pair of SHORT or BYTE values.
*/
static int
TIFFFetchShortPair(TIFF* tif, TIFFDirEntry* dir)
{
uint16 v[2];
int ok = 0;
switch (dir->tdir_type) {
case TIFF_SHORT:
case TIFF_SSHORT:
ok = TIFFFetchShortArray(tif, dir, v);
break;
case TIFF_BYTE:
case TIFF_SBYTE:
ok = TIFFFetchByteArray(tif, dir, v);
break;
}
if (ok)
TIFFSetField(tif, dir->tdir_tag, v[0], v[1]);
return (ok);
}
/*
* Fetch an array of LONG or SLONG values.
*/
static int
TIFFFetchLongArray(TIFF* tif, TIFFDirEntry* dir, uint32* v)
{
if (dir->tdir_count == 1) {
v[0] = dir->tdir_offset;
return (1);
} else
return (TIFFFetchData(tif, dir, (char*) v) != 0);
}
/*
* Fetch an array of RATIONAL or SRATIONAL values.
*/
static int
<API key>(TIFF* tif, TIFFDirEntry* dir, float* v)
{
int ok = 0;
uint32* l;
l = (uint32*)CheckMalloc(tif,
dir->tdir_count*TIFFDataWidth(dir->tdir_type),
"to fetch array of rationals");
if (l) {
if (TIFFFetchData(tif, dir, (char *)l)) {
uint32 i;
for (i = 0; i < dir->tdir_count; i++) {
ok = cvtRational(tif, dir,
l[2*i+0], l[2*i+1], &v[i]);
if (!ok)
break;
}
}
_TIFFfree((char *)l);
}
return (ok);
}
/*
* Fetch an array of FLOAT values.
*/
static int
TIFFFetchFloatArray(TIFF* tif, TIFFDirEntry* dir, float* v)
{
if (dir->tdir_count == 1) {
v[0] = *(float*) &dir->tdir_offset;
<API key>(tif, dir->tdir_count, v);
return (1);
} else if (TIFFFetchData(tif, dir, (char*) v)) {
<API key>(tif, dir->tdir_count, v);
return (1);
} else
return (0);
}
/*
* Fetch an array of DOUBLE values.
*/
static int
<API key>(TIFF* tif, TIFFDirEntry* dir, double* v)
{
if (TIFFFetchData(tif, dir, (char*) v)) {
<API key>(tif, dir->tdir_count, v);
return (1);
} else
return (0);
}
/*
* Fetch an array of ANY values. The actual values are
* returned as doubles which should be able hold all the
* types. Yes, there really should be an tany_t to avoid
* this potential non-portability ... Note in particular
* that we assume that the double return value vector is
* large enough to read in any fundamental type. We use
* that vector as a buffer to read in the base type vector
* and then convert it in place to double (from end
* to front of course).
*/
static int
TIFFFetchAnyArray(TIFF* tif, TIFFDirEntry* dir, double* v)
{
int i;
switch (dir->tdir_type) {
case TIFF_BYTE:
case TIFF_SBYTE:
if (!TIFFFetchByteArray(tif, dir, (uint16*) v))
return (0);
if (dir->tdir_type == TIFF_BYTE) {
uint16* vp = (uint16*) v;
for (i = dir->tdir_count-1; i >= 0; i
v[i] = vp[i];
} else {
int16* vp = (int16*) v;
for (i = dir->tdir_count-1; i >= 0; i
v[i] = vp[i];
}
break;
case TIFF_SHORT:
case TIFF_SSHORT:
if (!TIFFFetchShortArray(tif, dir, (uint16*) v))
return (0);
if (dir->tdir_type == TIFF_SHORT) {
uint16* vp = (uint16*) v;
for (i = dir->tdir_count-1; i >= 0; i
v[i] = vp[i];
} else {
int16* vp = (int16*) v;
for (i = dir->tdir_count-1; i >= 0; i
v[i] = vp[i];
}
break;
case TIFF_LONG:
case TIFF_SLONG:
if (!TIFFFetchLongArray(tif, dir, (uint32*) v))
return (0);
if (dir->tdir_type == TIFF_LONG) {
uint32* vp = (uint32*) v;
for (i = dir->tdir_count-1; i >= 0; i
v[i] = vp[i];
} else {
int32* vp = (int32*) v;
for (i = dir->tdir_count-1; i >= 0; i
v[i] = vp[i];
}
break;
case TIFF_RATIONAL:
case TIFF_SRATIONAL:
if (!<API key>(tif, dir, (float*) v))
return (0);
{ float* vp = (float*) v;
for (i = dir->tdir_count-1; i >= 0; i
v[i] = vp[i];
}
break;
case TIFF_FLOAT:
if (!TIFFFetchFloatArray(tif, dir, (float*) v))
return (0);
{ float* vp = (float*) v;
for (i = dir->tdir_count-1; i >= 0; i
v[i] = vp[i];
}
break;
case TIFF_DOUBLE:
return (<API key>(tif, dir, (double*) v));
default:
/* TIFF_NOTYPE */
/* TIFF_ASCII */
/* TIFF_UNDEFINED */
TIFFError(tif->tif_name,
"Cannot read TIFF_ANY type %d for field \"%s\"",
_TIFFFieldWithTag(tif, dir->tdir_tag)->field_name);
return (0);
}
return (1);
}
/*
* Fetch a tag that is not handled by special case code.
*/
/* The standard function TIFFFetchNormalTag() could definitely be replaced
with a simple call to this function, just adding TIFFSetField() as the
last argument. */
static int
<API key>(TIFF* tif, TIFFDirEntry* dp, const TIFFFieldInfo* fip,
int (*setFieldFn)(TIFF *tif, ttag_t tag, ...))
{
static char mesg[] = "to fetch tag value";
int ok = 0;
if (dp->tdir_count > 1) { /* array of values */
char* cp = NULL;
switch (dp->tdir_type) {
case TIFF_BYTE:
case TIFF_SBYTE:
/* NB: always expand BYTE values to shorts */
cp = CheckMalloc(tif,
dp->tdir_count * sizeof (uint16), mesg);
ok = cp && TIFFFetchByteArray(tif, dp, (uint16*) cp);
break;
case TIFF_SHORT:
case TIFF_SSHORT:
cp = CheckMalloc(tif,
dp->tdir_count * sizeof (uint16), mesg);
ok = cp && TIFFFetchShortArray(tif, dp, (uint16*) cp);
break;
case TIFF_LONG:
case TIFF_SLONG:
cp = CheckMalloc(tif,
dp->tdir_count * sizeof (uint32), mesg);
ok = cp && TIFFFetchLongArray(tif, dp, (uint32*) cp);
break;
case TIFF_RATIONAL:
case TIFF_SRATIONAL:
cp = CheckMalloc(tif,
dp->tdir_count * sizeof (float), mesg);
ok = cp && <API key>(tif, dp, (float*) cp);
break;
case TIFF_FLOAT:
cp = CheckMalloc(tif,
dp->tdir_count * sizeof (float), mesg);
ok = cp && TIFFFetchFloatArray(tif, dp, (float*) cp);
break;
case TIFF_DOUBLE:
cp = CheckMalloc(tif,
dp->tdir_count * sizeof (double), mesg);
ok = cp && <API key>(tif, dp, (double*) cp);
break;
case TIFF_ASCII:
case TIFF_UNDEFINED: /* bit of a cheat... */
/*
* Some vendors write strings w/o the trailing
* NULL byte, so always append one just in case.
*/
cp = CheckMalloc(tif, dp->tdir_count+1, mesg);
if (ok = (cp && TIFFFetchString(tif, dp, cp)))
cp[dp->tdir_count] = '\0'; /* XXX */
break;
}
if (ok) {
ok = (fip->field_passcount ?
(*setFieldFn)(tif, dp->tdir_tag, dp->tdir_count, cp)
: (*setFieldFn)(tif, dp->tdir_tag, cp));
}
if (cp != NULL)
_TIFFfree(cp);
} else if (CheckDirCount(tif, dp, 1)) { /* singleton value */
switch (dp->tdir_type) {
case TIFF_BYTE:
case TIFF_SBYTE:
case TIFF_SHORT:
case TIFF_SSHORT:
/*
* If the tag is also acceptable as a LONG or SLONG
* then (*setFieldFn) will expect an uint32 parameter
* passed to it (through varargs). Thus, for machines
* where sizeof (int) != sizeof (uint32) we must do
* a careful check here. It's hard to say if this
* is worth optimizing.
*
* NB: We use TIFFFieldWithTag here knowing that
* it returns us the first entry in the table
* for the tag and that that entry is for the
* widest potential data type the tag may have.
*/
{ TIFFDataType type = fip->field_type;
if (type != TIFF_LONG && type != TIFF_SLONG) {
uint16 v = (uint16)
TIFFExtractData(tif, dp->tdir_type, dp->tdir_offset);
ok = (fip->field_passcount ?
(*setFieldFn)(tif, dp->tdir_tag, 1, &v)
: (*setFieldFn)(tif, dp->tdir_tag, v));
break;
}
}
/* fall thru... */
case TIFF_LONG:
case TIFF_SLONG:
{ uint32 v32 =
TIFFExtractData(tif, dp->tdir_type, dp->tdir_offset);
ok = (fip->field_passcount ?
(*setFieldFn)(tif, dp->tdir_tag, 1, &v32)
: (*setFieldFn)(tif, dp->tdir_tag, v32));
}
break;
case TIFF_RATIONAL:
case TIFF_SRATIONAL:
case TIFF_FLOAT:
{ float v = (dp->tdir_type == TIFF_FLOAT ?
TIFFFetchFloat(tif, dp)
: TIFFFetchRational(tif, dp));
ok = (fip->field_passcount ?
(*setFieldFn)(tif, dp->tdir_tag, 1, &v)
: (*setFieldFn)(tif, dp->tdir_tag, v));
}
break;
case TIFF_DOUBLE:
{ double v;
ok = (<API key>(tif, dp, &v) &&
(fip->field_passcount ?
(*setFieldFn)(tif, dp->tdir_tag, 1, &v)
: (*setFieldFn)(tif, dp->tdir_tag, v))
);
}
break;
case TIFF_ASCII:
case TIFF_UNDEFINED: /* bit of a cheat... */
{ char c[2];
if (ok = (TIFFFetchString(tif, dp, c) != 0)) {
c[1] = '\0'; /* XXX paranoid */
ok = (*setFieldFn)(tif, dp->tdir_tag, c);
}
}
break;
}
}
return (ok);
}
/* Everything after this is exactly duplicated from the standard tif_dirread.c
file, necessitated by the fact that they are declared static there so
we can't call them!
*/
#define NITEMS(x) (sizeof (x) / sizeof (x[0]))
/*
* Fetch samples/pixel short values for
* the specified tag and verify that
* all values are the same.
*/
static int
<API key>(TIFF* tif, TIFFDirEntry* dir, int* pl)
{
int samples = tif->tif_dir.td_samplesperpixel;
int status = 0;
if (CheckDirCount(tif, dir, (uint32) samples)) {
uint16 buf[10];
uint16* v = buf;
if (samples > NITEMS(buf))
v = (uint16*) _TIFFmalloc(samples * sizeof (uint16));
if (TIFFFetchShortArray(tif, dir, v)) {
int i;
for (i = 1; i < samples; i++)
if (v[i] != v[0]) {
TIFFError(tif->tif_name,
"Cannot handle different per-sample values for field \"%s\"",
_TIFFFieldWithTag(tif, dir->tdir_tag)->field_name);
goto bad;
}
*pl = v[0];
status = 1;
}
bad:
if (v != buf)
_TIFFfree((char*) v);
}
return (status);
}
/*
* Fetch samples/pixel ANY values for
* the specified tag and verify that
* all values are the same.
*/
static int
<API key>(TIFF* tif, TIFFDirEntry* dir, double* pl)
{
int samples = (int) tif->tif_dir.td_samplesperpixel;
int status = 0;
if (CheckDirCount(tif, dir, (uint32) samples)) {
double buf[10];
double* v = buf;
if (samples > NITEMS(buf))
v = (double*) _TIFFmalloc(samples * sizeof (double));
if (TIFFFetchAnyArray(tif, dir, v)) {
int i;
for (i = 1; i < samples; i++)
if (v[i] != v[0]) {
TIFFError(tif->tif_name,
"Cannot handle different per-sample values for field \"%s\"",
_TIFFFieldWithTag(tif, dir->tdir_tag)->field_name);
goto bad;
}
*pl = v[0];
status = 1;
}
bad:
if (v != buf)
_TIFFfree(v);
}
return (status);
}
#undef NITEMS
/*
* Fetch a set of offsets or lengths.
* While this routine says "strips",
* in fact it's also used for tiles.
*/
static int
TIFFFetchStripThing(TIFF* tif, TIFFDirEntry* dir, long nstrips, uint32** lpp)
{
register uint32* lp;
int status;
if (!CheckDirCount(tif, dir, (uint32) nstrips))
return (0);
/*
* Allocate space for strip information.
*/
if (*lpp == NULL &&
(*lpp = (uint32 *)CheckMalloc(tif,
nstrips * sizeof (uint32), "for strip array")) == NULL)
return (0);
lp = *lpp;
if (dir->tdir_type == (int)TIFF_SHORT) {
/*
* Handle uint16->uint32 expansion.
*/
uint16* dp = (uint16*) CheckMalloc(tif,
dir->tdir_count* sizeof (uint16), "to fetch strip tag");
if (dp == NULL)
return (0);
if (status = TIFFFetchShortArray(tif, dir, dp)) {
register uint16* wp = dp;
while (nstrips
*lp++ = *wp++;
}
_TIFFfree((char*) dp);
} else
status = TIFFFetchLongArray(tif, dir, lp);
return (status);
}
#define NITEMS(x) (sizeof (x) / sizeof (x[0]))
/*
* Fetch and set the ExtraSamples tag.
*/
static int
<API key>(TIFF* tif, TIFFDirEntry* dir)
{
uint16 buf[10];
uint16* v = buf;
int status;
if (dir->tdir_count > NITEMS(buf))
v = (uint16*) _TIFFmalloc(dir->tdir_count * sizeof (uint16));
if (dir->tdir_type == TIFF_BYTE)
status = TIFFFetchByteArray(tif, dir, v);
else
status = TIFFFetchShortArray(tif, dir, v);
if (status)
status = TIFFSetField(tif, dir->tdir_tag, dir->tdir_count, v);
if (v != buf)
_TIFFfree((char*) v);
return (status);
}
#undef NITEMS
#ifdef COLORIMETRY_SUPPORT
/*
* Fetch and set the RefBlackWhite tag.
*/
static int
<API key>(TIFF* tif, TIFFDirEntry* dir)
{
static char mesg[] = "for \"ReferenceBlackWhite\" array";
char* cp;
int ok;
if (dir->tdir_type == TIFF_RATIONAL)
return (1/*TIFFFetchNormalTag(tif, dir) just so linker won't complain - this part of the code is never used anyway */);
/*
* Handle LONG's for backward compatibility.
*/
cp = CheckMalloc(tif, dir->tdir_count * sizeof (uint32), mesg);
if (ok = (cp && TIFFFetchLongArray(tif, dir, (uint32*) cp))) {
float* fp = (float*)
CheckMalloc(tif, dir->tdir_count * sizeof (float), mesg);
if (ok = (fp != NULL)) {
uint32 i;
for (i = 0; i < dir->tdir_count; i++)
fp[i] = (float)((uint32*) cp)[i];
ok = TIFFSetField(tif, dir->tdir_tag, fp);
_TIFFfree((char*) fp);
}
}
if (cp)
_TIFFfree(cp);
return (ok);
}
#endif
#if STRIPCHOP_SUPPORT
/*
* Replace a single strip (tile) of uncompressed data by
* multiple strips (tiles), each approximately 8Kbytes.
* This is useful for dealing with large images or
* for dealing with machines with a limited amount
* memory.
*/
static void
<API key>(TIFF* tif)
{
register TIFFDirectory *td = &tif->tif_dir;
uint32 bytecount = td->td_stripbytecount[0];
uint32 offset = td->td_stripoffset[0];
tsize_t rowbytes = TIFFVTileSize(tif, 1), stripbytes;
tstrip_t strip, nstrips, rowsperstrip;
uint32* newcounts;
uint32* newoffsets;
/*
* Make the rows hold at least one
* scanline, but fill 8k if possible.
*/
if (rowbytes > 8192) {
stripbytes = rowbytes;
rowsperstrip = 1;
} else {
rowsperstrip = 8192 / rowbytes;
stripbytes = rowbytes * rowsperstrip;
}
/* never increase the number of strips in an image */
if (rowsperstrip >= td->td_rowsperstrip)
return;
nstrips = (tstrip_t) TIFFhowmany(bytecount, stripbytes);
newcounts = (uint32*) CheckMalloc(tif, nstrips * sizeof (uint32),
"for chopped \"StripByteCounts\" array");
newoffsets = (uint32*) CheckMalloc(tif, nstrips * sizeof (uint32),
"for chopped \"StripOffsets\" array");
if (newcounts == NULL || newoffsets == NULL) {
/*
* Unable to allocate new strip information, give
* up and use the original one strip information.
*/
if (newcounts != NULL)
_TIFFfree(newcounts);
if (newoffsets != NULL)
_TIFFfree(newoffsets);
return;
}
/*
* Fill the strip information arrays with
* new bytecounts and offsets that reflect
* the broken-up format.
*/
for (strip = 0; strip < nstrips; strip++) {
if (stripbytes > bytecount)
stripbytes = bytecount;
newcounts[strip] = stripbytes;
newoffsets[strip] = offset;
offset += stripbytes;
bytecount -= stripbytes;
}
/*
* Replace old single strip info with multi-strip info.
*/
td->td_stripsperimage = td->td_nstrips = nstrips;
TIFFSetField(tif, <API key>, rowsperstrip);
_TIFFfree(td->td_stripbytecount);
_TIFFfree(td->td_stripoffset);
td->td_stripbytecount = newcounts;
td->td_stripoffset = newoffsets;
}
#endif /* STRIPCHOP_SUPPORT */
|
package org.apache.hadoop.hive.kafka.camus;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.MapWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.io.UTF8;
import org.apache.hadoop.io.Writable;
import org.apache.hadoop.io.WritableComparable;
import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;
import java.util.Map;
/**
* The key for the mapreduce job to pull kafka. Contains offsets and the
* checksum.
*/
public class KafkaKey implements WritableComparable<KafkaKey>, IKafkaKey {
public static final Text SERVER = new Text("server");
public static final Text SERVICE = new Text("service");
public static KafkaKey DUMMY_KEY = new KafkaKey();
private String leaderId = "";
private int partition = 0;
private long beginOffset = 0;
private long offset = 0;
private long checksum = 0;
private String topic = "";
private long time = 0;
private String server = "";
private String service = "";
private MapWritable partitionMap = new MapWritable();
/**
* dummy empty constructor
*/
public KafkaKey() {
this("dummy", "0", 0, 0, 0, 0);
}
public KafkaKey(KafkaKey other) {
this.partition = other.partition;
this.beginOffset = other.beginOffset;
this.offset = other.offset;
this.checksum = other.checksum;
this.topic = other.topic;
this.time = other.time;
this.server = other.server;
this.service = other.service;
this.partitionMap = new MapWritable(other.partitionMap);
}
public KafkaKey(String topic, String leaderId, int partition) {
this.set(topic, leaderId, partition, 0, 0, 0);
}
public KafkaKey(String topic, String leaderId, int partition, long beginOffset, long offset) {
this.set(topic, leaderId, partition, beginOffset, offset, 0);
}
public KafkaKey(String topic, String leaderId, int partition, long beginOffset, long offset, long checksum) {
this.set(topic, leaderId, partition, beginOffset, offset, checksum);
}
public void set(String topic, String leaderId, int partition, long beginOffset, long offset, long checksum) {
this.leaderId = leaderId;
this.partition = partition;
this.beginOffset = beginOffset;
this.offset = offset;
this.checksum = checksum;
this.topic = topic;
this.time = System.currentTimeMillis(); // if event can't be decoded,
// this time will be used for
// debugging.
}
public void clear() {
leaderId = "";
partition = 0;
beginOffset = 0;
offset = 0;
checksum = 0;
topic = "";
time = 0;
server = "";
service = "";
partitionMap = new MapWritable();
}
public String getServer() {
return partitionMap.get(SERVER).toString();
}
public void setServer(String newServer) {
partitionMap.put(SERVER, new Text(newServer));
}
public String getService() {
return partitionMap.get(SERVICE).toString();
}
public void setService(String newService) {
partitionMap.put(SERVICE, new Text(newService));
}
public long getTime() {
return time;
}
public void setTime(long time) {
this.time = time;
}
public String getTopic() {
return topic;
}
public String getLeaderId() {
return leaderId;
}
public int getPartition() {
return this.partition;
}
public long getBeginOffset() {
return this.beginOffset;
}
public void setOffset(long offset) {
this.offset = offset;
}
public long getOffset() {
return this.offset;
}
public long getChecksum() {
return this.checksum;
}
@Override
public long getMessageSize() {
Text key = new Text("message.size");
if (this.partitionMap.containsKey(key))
return ((LongWritable) this.partitionMap.get(key)).get();
else
return 1024; //default estimated size
}
public void setMessageSize(long messageSize) {
Text key = new Text("message.size");
put(key, new LongWritable(messageSize));
}
public void put(Writable key, Writable value) {
this.partitionMap.put(key, value);
}
public void addAllPartitionMap(MapWritable partitionMap) {
this.partitionMap.putAll(partitionMap);
}
public MapWritable getPartitionMap() {
return partitionMap;
}
@Override
public void readFields(DataInput in) throws IOException {
this.leaderId = UTF8.readString(in);
this.partition = in.readInt();
this.beginOffset = in.readLong();
this.offset = in.readLong();
this.checksum = in.readLong();
this.topic = in.readUTF();
this.time = in.readLong();
this.server = in.readUTF(); // left for legacy
this.service = in.readUTF(); // left for legacy
this.partitionMap = new MapWritable();
try {
this.partitionMap.readFields(in);
} catch (IOException e) {
this.setServer(this.server);
this.setService(this.service);
}
}
@Override
public void write(DataOutput out) throws IOException {
UTF8.writeString(out, this.leaderId);
out.writeInt(this.partition);
out.writeLong(this.beginOffset);
out.writeLong(this.offset);
out.writeLong(this.checksum);
out.writeUTF(this.topic);
out.writeLong(this.time);
out.writeUTF(this.server); // left for legacy
out.writeUTF(this.service); // left for legacy
this.partitionMap.write(out);
}
@Override
public int compareTo(KafkaKey o) {
if (partition != o.partition) {
return partition = o.partition;
} else {
if (offset > o.offset) {
return 1;
} else if (offset < o.offset) {
return -1;
} else {
if (checksum > o.checksum) {
return 1;
} else if (checksum < o.checksum) {
return -1;
} else {
return 0;
}
}
}
}
@Override
public String toString() {
StringBuilder builder = new StringBuilder();
builder.append("topic=");
builder.append(topic);
builder.append(" partition=");
builder.append(partition);
builder.append("leaderId=");
builder.append(leaderId);
builder.append(" server=");
builder.append(server);
builder.append(" service=");
builder.append(service);
builder.append(" beginOffset=");
builder.append(beginOffset);
builder.append(" offset=");
builder.append(offset);
builder.append(" msgSize=");
builder.append(getMessageSize());
builder.append(" server=");
builder.append(server);
builder.append(" checksum=");
builder.append(checksum);
builder.append(" time=");
builder.append(time);
for (Map.Entry<Writable, Writable> e : partitionMap.entrySet()) {
builder.append(" " + e.getKey() + "=");
builder.append(e.getValue().toString());
}
return builder.toString();
}
}
|
package com.datawizards.dmg.service
import com.datawizards.dmg.repository.{<API key>, <API key>}
class <API key>(url: String) extends <API key> {
override protected val repository: <API key> = new <API key>(url)
override protected val hdfsService: HDFSService = HDFSServiceImpl
}
|
package net.unicon.cas.addons.serviceregistry;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.<API key>;
import org.springframework.beans.factory.config.<API key>;
import org.springframework.beans.factory.support.<API key>;
/**
* <code><API key></code> to remove 2 quartz beans responsible for reloading the default services registry's registered services.
* <p/>
* Useful in cases where other facilities are responsible for reloading in-memory services cache, for example on-demand reloading
* of JSON services registry, etc.
* <p/>
* This bean just needs to be declared in CAS' application context and upon bootstrap Spring will call back into it and
* 2 scheduling quartz beans dedicated for services registry reloading thread will be removed from the final application context
* effectively disabling the default reloading behavior.
*
* @author Dmitriy Kopylenko
* @author Unicon, inc.
* @since 1.8
*/
public class <API key> implements <API key> {
private static final String <API key> = "<API key>";
private static final String <API key> = "<API key>";
private static final Logger logger = LoggerFactory.getLogger(<API key>.class);
public void <API key>(<API key> beanFactory) throws BeansException {
logger.debug("Removing [{}] bean definition from the application context...", <API key>);
<API key>.class.cast(beanFactory).<API key>(<API key>);
logger.debug("Removing [{}] bean definition from the application context...", <API key>);
<API key>.class.cast(beanFactory).<API key>(<API key>);
}
}
|
package dhg.util
import scala.collection.generic.CanBuildFrom
object Pattern {
object UInt {
val IntRE = .r
def unapply(v: String): Option[Int] = v match {
case IntRE(s) => Some(s.toInt)
case _ => None
}
}
// implicit def int2unapplyInt(objA: Int.type) = UInt
object UDouble {
val DoubleRE = """^(-?\d+\.?\d*|-?\d*\.?\d+)$""".r
def unapply(v: String): Option[Double] = v match {
case DoubleRE(s) => Some(s.toDouble)
case _ => None
}
}
// implicit def <API key>(objA: Double.type) = UDouble
object UBoolean {
val booleanRE = """([Tt][Rr][Uu][Ee]|[Ff][Aa][Ll][Ss][Ee])""".r
def unapply(v: String): Option[Boolean] = v match {
case booleanRE(s) => Some(s.toBoolean)
case _ => None
}
}
object UMap {
def unapplySeq[A, B](m: Map[A, B]): Option[Seq[(A, B)]] = Some(m.toIndexedSeq)
}
object USet {
def unapplySeq[A](s: Set[A]): Option[Seq[A]] = Some(s.toIndexedSeq)
}
object -> {
def unapply[A, B](pair: (A, B)): Option[(A, B)] = {
Some(pair)
}
}
object Range {
val RangeRE = .r
def unapply(s: String): Option[Seq[Int]] = Some(
s.replaceAll("\\s+", "").split(",").flatMap {
case UInt(i) => i to i
case RangeRE(UInt(b), UInt(e)) if b <= e => b to e
})
}
class Range(max: Int) {
val OpenRangeRE = .r
def unapply(s: String): Option[Seq[Int]] = Some(
s.replaceAll("\\s+", "").split(",").flatMap {
case OpenRangeRE(UInt(b)) => b to max
case Range(r) => r
})
}
def makeRangeString(seq: Seq[Int]): String = {
assert(seq.nonEmpty, "cannot make empty sequence into a range string")
assert(seq.exists(_ >= 0), s"negative numbers are not permitted: $seq")
(-2 +: seq).sliding(2).foldLeft(Vector[Vector[Int]]()) {
case ((z :+ c), Seq(a, b)) =>
if (a != b - 1)
(z :+ c) :+ Vector(b)
else
(z :+ (c :+ b))
case (z, Seq(a, b)) =>
z :+ Vector(b)
}
.map {
case Seq(x) => x.toString
case s => s.head + "-" + s.last
}.mkString(",")
}
object Iterable {
def unapplySeq[T](s: Iterable[T]): Option[Seq[T]] =
Some(s.toIndexedSeq)
}
}
|
using ClassLibrary;
using Pokemon_IMIE.Model;
using Pokemon_IMIE.usercontrols;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices.WindowsRuntime;
using Windows.Foundation;
using Windows.Foundation.Collections;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;
using Windows.UI.Xaml.Controls.Primitives;
using Windows.UI.Xaml.Data;
using Windows.UI.Xaml.Input;
using Windows.UI.Xaml.Media;
using Windows.UI.Xaml.Navigation;
namespace Pokemon_IMIE.usercontrols
{
public sealed partial class PokemonStatus : BaseUserControl
{
private Model.Pokemon pokemon;
public Model.Pokemon Pokemon
{
get { return pokemon; }
set
{
pokemon = value;
base.OnPropertyChanged("Pokemon");
}
}
public PokemonStatus()
{
this.InitializeComponent();
base.DataContext = this;
}
}
}
|
#coding=utf-8
from django.db import models
from django.contrib.auth.models import User
class Activity(models.Model):
owner = models.ForeignKey(User, null=False)
text = models.CharField(max_length=20, unique=True)
class Dessert(models.Model):
activity = models.ForeignKey(Activity, null=False)
description = models.TextField()
photo = models.ImageField()
|
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Day57-vlvibesSwitch</title>
<script src="https://aframe.io/releases/0.2.0/aframe.min.js"></script>
<script src="https://rawgit.com/ngokevin/<API key>/master/dist/<API key>.min.js"></script>
<script src="https://code.jquery.com/jquery-2.1.1.js"></script>
</head>
<body>
<a-scene>
<!-- camera -->
<a-entity id="camera" rotation="0 0 0" position="0 0 0">
<a-camera>
<a-entity cursor="maxDistance:10000" position="0 0 -1" color="pink" geometry="primitive:ring; color:pink; radiusInner:.005; radiusOuter:.01"></a-entity>
</a-camera>
</a-entity>
<!--divs and baloon
<a-entity id="titleName"></a-entity>
<a-entity id="sphereA">
<a-sphere id="sphere1" visable="true" material="src:url(http:
<a-animation attribute="position" from="0 -20 -2" to="0 0 -2"></a-animation>
</a-entity>
<!-- light -->
<a-entity><a-entity id="light" light="color:#F5F5F5; intensity:2" position="-1 3 2"></a-entity></a-entity>
<!-- sounds -->
<a-entity id="vibes" geometry="primitive: plane" material="color: pink" position="-10 0 0" sound="src: vibes.mp3; autoplay: false"></a-entity>
<a-entity id="mainMenu" position="-4.5 3.5 -8"><a-plane material="src:url(https://encrypted-tbn3.gstatic.com/images?q=tbn:<API key>)"></a-plane></a-entity>
<a-sky color="#333"></a-sky>
</a-scene>
<script>
$(document).ready(function(){
document.querySelector('#sphere1').addEventListener('click', function () {
// text add
$("a-scene").append('<a-entity><a-entity material="color:#F16785" scale="5 5 5" text="text:Lay ut"></a-entity><a-animation begin="500" attribute="position" from="20 0 -10" to=".15 0 -10"></a-animation></a-entity>');
$("a-scene").append('<a-entity><a-entity material="color:#F16785" scale="5 5 5" text="text:Virtual"></a-entity><a-animation begin="500" attribute="position" from="-20 0 -10" to="-10.5 0 -10"></a-animation></a-entity>');
// welcome slide in and slide out
$("a-scene").append('<a-entity><a-entity material="color:#F16785" scale="1 1 1" text="text:Welcome to"></a-entity><a-animation begin="1100" attribute="position" from="-20 3 -10" to="-4 3 -10"></a-animation><a-animation begin="2000" attribute="position" from="-4 3 -10" to="-40 3 -10"></a-animation><a-animation begin="6050" attribute="position" from="-43 3 -10" to="-8 3 -10 -10"></a-animation></a-entity>');
// animated spotlight
$("a-scene").append('<a-entity><a-entity id="spotLight" light="color:#F5F5F5; type:spot; intensity:1.8; angle:10"></a-entity><a-animation id="durAnimation" attribute="position" dur="5000" from="-25 -2 2" to="25 -1 4" repeat="indefinite"></a-animation></a-entity>');
// remove original sphere
$(this).hide(1,function(){$(this).remove();});
// create new sphere
$("a-scene").append('<a-entity id="sphereB" camera"><a-sphere position="0 0 -2" id="sphere1" material="src:url(http:
// sphere slammer
$("a-scene").append('<a-entity id="sphereRod"><a-cylinder></a-cylinder height="5"><a-animation begin="3800" attribute="position" from="6.58 20 -10" to="6.58 3.5 -10"></a-animation><a-animation begin="4500" attribute="position" from="6.58 3.5 -10" to="6.58 20 -10"></a-animation></a-entity>')
// welcome slammer
$("a-scene").append('<a-entity id="welcomeRod"><a-cylinder></a-cylinder height="5" rotation="0 0 180"><a-animation begin="6000" attribute="position" from="-41 3 -10" to="-10 3 -10 -10"></a-animation><a-animation begin="7500" attribute="position" from="-10 3 -10" to="-100 3 -10"></a-animation></a-entity>')
});
document.querySelector('#mainMenu').addEventListener('toggle', function(){
$('a-scene').append('<a-entity id="lightSwitch"><a-plane material="src:url(https://d13yacurqjgara.cloudfront.net/users/63537/screenshots/1069396/toggle.gif)" position="-5.5 -3.5 -8"></a-plane></a-entity>')
$('a-scene').append('<a-entity id="sphereMenu"><a-plane material="src:url(https://cdn2.iconfinder.com/data/icons/<API key>/128/switch.png)" position="-5.5 3.5 -8"></a-plane></a-entity>')
$('a-scene').append('<a-entity id="fogSwitch"><a-plane material="src:url(https://encrypted-tbn1.gstatic.com/images?q=tbn:<API key>)" position="-5.5 -7 -8"></a-plane></a-entity>')
$('a-scene').append('<a-entity id=spotLightSpeed><a-plane material="src:url(https://cdn0.iconfinder.com/data/icons/astronomy-1/500/speed-512.png)" position="-5.5 -9.5 -8"></a-plane></a-entity>');
$('a-scene').append('<a-entity id="cameraSwitch"><a-plane material="src:url()" position="-5.5 -12 -8"></a-plane></a-entity>');
$('a-scene')append('<a-entity id="vibesSwitch"><a-plane material="src:url()" position="-5.5 -14.5 -8"></a-plane></a-entity>')
})
document.querySelector('#sphereMenu').addEventListener('click', function () {
$('a-scene').append('<a-entity id="MENU"><a-plane height="2" width="10" position="2 5 -7"></a-plane></a-entity>')
$('a-scene').append('<a-plane id="futbol" height="1.5" width="1.5" position="-1.5 5 -6.8" material="src:url(http:
$('a-scene').append('<a-entity id="bask"><a-plane id="basketball" height="1.5" width="1.5" position=".5 5 -6.8" material="src:url(http:
});
document.querySelector('#bask').addEventListener('toggle', function () {
$('
});
document.querySelector('#lightSwitch').addEventListener('click', function () {
$('#light').attr('light','color:#555555; intensity:5');
});
document.querySelector('#fogSwitch').addEventListener('click', function () {
$('#light').attr('light','color:#555555; intensity:5');
});
document.querySelector('#spotLightSpeed').addEventListener('click', function () {
$('#durAnimation').attr('dur','3000');
});
document.querySelector('#cameraSwitch').addEventListener('click', function () {
$('#camera').attr('position','5 0 0');
$('#camera').attr('rotation','20 0 0');
});
document.querySelector('#vibesSwitch').addEventListener('click', function(){
$('#vibes').attr('autoplay', 'true');
})
});
</script>
</body>
</html>
|
var angularjs = angular.module('articleDetailModule', ['<API key>', 'ngCookies', 'ngVideo']);
angularjs.controller('<API key>', ['$rootScope', '$scope',
'$http', '$stateParams', '$state', '$location',
'CourseTagService', '$sce', '$cookies', '$httpParamSerializer', 'video', '$route',
function($rootScope, $scope, $http, $stateParams,
$state, $location, courseTagSrv, $sce, $cookies, $httpParamSerializer,
video, $route) {
if ($stateParams.courseId === undefined) {
$state.go('home');
}
var token = $location.search().token;
if (token !== undefined) {
console.log('set token on cookie');
$cookies.put('access_token', token);
}
$scope.showShare = false;
$scope.shareImg = "img/share_400_400_2.png";
$scope.courseUrl = $location.absUrl();
console.log('location=', $scope.courseUrl);
var util = new DomainNameUtil($location);
$scope.originUrl = window.location.href;
console.log('get access token:', $cookies.get('access_token'));
$scope.favoriteCls = '<API key>';
$scope.favoriteText = '';
$http.get(util.<API key>() +
'/course/proposal/' + $stateParams.courseId, {
headers: {
'access_token': $cookies.get('access_token')
}
}).
success(function(e) {
console.log('get course ', e);
$scope.course = e;
$rootScope.title = e.name;
var $body = $('body');
var $iframe = $('<iframe src="/favicon.ico"></iframe>');
$iframe.on('load', function() {
setTimeout(function() {
$iframe.off('load').remove();
}, 0);
}).appendTo($body);
$scope.course.videoUrl = $sce.trustAsResourceUrl($scope.course.videoUrl);
document.getElementById('article_content').innerHTML = $scope.course.content;
// video.addSource('mp4',$scope.course.videoUrl);
setFavoriteDom();
configJSAPI();
}).error(function(e) {
});
$http.get(util.<API key>() +
'/course/proposal/query?number=3&ignore_course_id=' + $stateParams.courseId)
.success(function(e) {
console.log('get related courses ', e);
$scope.relatedCourses = e;
}).error(function(e) {
});
courseTagSrv.getCourseTags().then(function(e) {
$scope.courseTags = e;
});
$scope.background = function(course) {
return {
'background-image': 'url(' + course.titleImageUrl + ')',
'background-size': '100%'
};
}
$scope.goToCourseTag = function(tag, $event) {
console.log('go to course tag');
$state.go('course_tags', {
courseTagId: tag.id,
courseName: tag.name
});
$event.stopPropagation();
}
$scope.share = function() {
console.log('share');
$scope.showShare = true;
// var ret = recordShareFavorite('SHARE');
// ret.success(function(e){
}
$scope.favorite = function() {
console.log('favorite');
if ($cookies.get('access_token') === undefined) {
var redirect = encodeURI($scope.courseUrl).replace('
console.log('redirect=', encodeURI($scope.courseUrl).replace('
window.location.href = 'https://open.weixin.qq.com/connect/oauth2/authorize?appid=wxfe34c2ab5b5c5813&redirect_uri=http%3a%2f%2fwww.imzao.com%2feducation%2fzaozao%2fwechat%2flogin&response_type=code&scope=snsapi_userinfo&state=WECHAT_SERVICE-' + redirect + '#wechat_redirect';
return;
}
var promise = recordShareFavorite('FAVORITE');
promise.success(function(e) {
console.log('favorite success ', e);
$scope.course.favorited = !$scope.course.favorited;
setFavoriteDom();
}).error(function(e) {
console.log('share failed');
});
}
function setFavoriteDom() {
if ($scope.course.favorited === true) {
$scope.favoriteCls = 'fontawesome-heart';
$scope.favoriteText = '';
} else {
$scope.favoriteCls = '<API key>';
$scope.favoriteText = '';
}
}
$scope.hideShare = function() {
$scope.showShare = false;
}
$scope.showPlayButton = true;
$scope.showVideo = false;
$scope.playVideo = function(e) {
console.log('course video,', $("#course_video"));
$("#course_video")[0].play();
}
document.getElementById('course_video').addEventListener('webkitendfullscreen', function(e) {
// handle end full screen
console.log('webkitendfullscreen');
$scope.showVideo = false;
$scope.showPlayButton = true;
$scope.$apply();
});
document.getElementById('course_video').addEventListener('<API key>', function(e) {
// handle end full screen
console.log('<API key>');
$scope.showVideo = true;
$scope.$apply();
});
// $scope.videoEnded = function(e) {
// console.log('video ended ');
// $scope.showPlayButton = true;
// $scope.videoPaused = function(e) {
// console.log('video paused ');
// $scope.showPlayButton = true;
function configJSAPI() {
console.log('js api config:', $scope.courseUrl);
$http.get(util.<API key>() + '/wechat/jsapi?url=' + $scope.courseUrl.split('#')[0].replace('&', '%26'))
.success(function(e) {
console.log(e);
var signature = e;
wx.config({
debug: false,
appId: e.appid,
timestamp: e.timestamp,
nonceStr: e.noncestr,
signature: e.signature,
jsApiList: ['checkJsApi', 'onMenuShareTimeline', '<API key>']
});
wx.ready(function() {
console.log('wx ready');
});
wx.error(function(res) {
console.log('wx error');
});
wx.onMenuShareTimeline({
title: $scope.course.name,
link: $scope.courseUrl,
imgUrl: encodeURI($scope.course.titleImageUrl),
success: function() {
console.log('share success');
scope.showShare = false;
recordShareFavorite('SHARE');
},
cancel: function() {
console.log('cancel share');
scope.showShare = false;
}
});
var shareDesc = '';
console.log('share desc:', $scope.course.introduction);
if ($scope.course.introduction !== null && $scope.course.introduction !== 'undefined') {
shareDesc = $scope.course.introduction;
}
wx.<API key>({
title: $scope.course.name,
desc: shareDesc,
link: $scope.courseUrl,
imgUrl: encodeURI($scope.course.titleImageUrl),
// ,musicvideolinklink
// typemusicvideo
success: function(res) {
console.log('share success');
recordShareFavorite('SHARE');
scope.showShare = false;
},
cancel: function(res) {
console.log('cancel share');
scope.showShare = false;
},
fail: function(res) {
}
});
}).error(function(e) {
});
}
function recordShareFavorite(activity) {
var link = util.<API key>() + '/course/interactive';
var req = {
method: 'POST',
url: link,
headers: {
'Content-Type': 'application/<API key>;charset=UTF-8',
'access_token': $cookies.get('access_token')
//'Content-Type': 'multipart/form-data; charset=utf-8;'
},
data: $httpParamSerializer({
course_id: $scope.course.id,
flag: activity
})
};
return $http(req);
}
}
]);
angularjs.directive('videoLoader', function() {
return function(scope, element, attrs) {
scope.$watch(attrs.videoLoader, function() {
console.log('element:', element);
$("#course_video").bind('ended', function() {
console.log('video ended.');
// element.removeAttr('controls');
scope.showPlayButton = true;
scope.showVideo = false;
scope.$apply();
// $(this).unbind('ended');
// if (!this.hasPlayed) {
// return;
});
$("#course_video").bind('pause', function() {
console.log('video paused.');
scope.showPlayButton = false;
scope.showVideo = true;
// element.attr('controls',true);
scope.$apply();
// $(this).unbind('paused');
// if (!this.hasPlayed) {
// return;
});
$("#course_video").bind('play', function() {
console.log('video played.');
scope.showPlayButton = false;
scope.showVideo = true;
// element.attr('controls',true);
scope.$apply();
// $(this).unbind('played');
// if (!this.hasPlayed) {
// return;
});
$("#course_video").bind('<API key> mozfullscreenchange fullscreenchange',
function(event) {
console.log('full screen ', event);
var state = document.fullscreenElement ||
document.<API key> ||
document.<API key> ||
document.msFullscreenElement;
if (state !== undefined) {
scope.showVideo = true;
} else {
scope.showVideo = false;
}
scope.$apply();
});
});
}
});
|
package org.semanticweb.HermiT.datatypes.owlreal;
import java.math.BigDecimal;
import java.math.BigInteger;
public enum NumberRange {
NOTHING, INTEGER, DECIMAL, RATIONAL, REAL;
public boolean isDense() {
return ordinal() >= DECIMAL.ordinal();
}
public static NumberRange intersection(NumberRange it1, NumberRange it2) {
int minOrdinal = Math.min(it1.ordinal(), it2.ordinal());
return values()[minOrdinal];
}
public static NumberRange union(NumberRange it1, NumberRange it2) {
int maxOrdinal = Math.max(it1.ordinal(), it2.ordinal());
return values()[maxOrdinal];
}
public static boolean isSubsetOf(NumberRange subset, NumberRange superset) {
return subset.ordinal() <= superset.ordinal();
}
public static NumberRange <API key>(Number n) {
if (n instanceof Integer || n instanceof Long || n instanceof BigInteger)
return INTEGER;
else if (n instanceof BigDecimal)
return DECIMAL;
else if (n instanceof BigRational)
return RATIONAL;
else
throw new <API key>();
}
}
|
// <summary>
// Describes a recipe.
// </summary>
namespace ForkTip.Models
{
using System;
using System.Collections.Generic;
<summary>
Describes a recipe.
</summary>
[Serializable]
public class Recipe
{
<summary>
Gets or sets the id.
</summary>
public Guid Id { get; set; }
<summary>
Gets or sets the name.
</summary>
public string Name { get; set; }
<summary>
Gets or sets the creator's name.
</summary>
public string Author { get; set; }
<summary>
Gets or sets the description.
</summary>
public string Description { get; set; }
<summary>
Gets or sets the ingredients.
</summary>
public List<string> Ingredients { get; set; }
<summary>
Gets or sets the directions.
</summary>
public List<string> Directions { get; set; }
}
}
|
package com.designpattern.structural.facade;
public class Facade {
SystemOne system1 = new SystemOne();
SystemTwo system2 = new SystemTwo();
SystemThree system3 = new SystemThree();
SystemFour system4 = new SystemFour();
public void facadeFunction1() {
System.out.println("---- facade function 1");
system1.methodOne();
system3.methodThree();
system4.methodFour();
System.out.println("---- facade function 1 end");
}
public void facadeFunction2() {
System.out.println("---- facade function 2");
system2.methodTwo();
system3.methodThree();
System.out.println("---- facade function 2 end");
}
}
|
<!DOCTYPE HTML PUBLIC "-
<!-- NewPage -->
<html lang="en">
<head>
<!-- Generated by javadoc (1.8.0_92) on Wed Jul 27 21:27:29 CEST 2016 -->
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title><API key> (PMD Python 5.5.1 API)</title>
<meta name="date" content="2016-07-27">
<link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
<script type="text/javascript" src="../../../../../../script.js"></script>
</head>
<body>
<script type="text/javascript"><!
try {
if (location.href.indexOf('is-external=true') == -1) {
parent.document.title="<API key> (PMD Python 5.5.1 API)";
}
}
catch(err) {
}
</script>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
<div class="topNav"><a name="navbar.top">
</a>
<div class="skipNav"><a href="#skip.navbar.top" title="Skip navigation links">Skip navigation links</a></div>
<a name="navbar.top.firstrow">
</a>
<ul class="navList" title="Navigation">
<li><a href="../../../../../../overview-summary.html">Overview</a></li>
<li><a href="package-summary.html">Package</a></li>
<li class="navBarCell1Rev">Class</li>
<li><a href="class-use/<API key>.html">Use</a></li>
<li><a href="package-tree.html">Tree</a></li>
<li><a href="../../../../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../../../../index-all.html">Index</a></li>
<li><a href="../../../../../../help-doc.html">Help</a></li>
</ul>
</div>
<div class="subNav">
<ul class="navList">
<li>Prev Class</li>
<li><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html" title="class in net.sourceforge.pmd.lang.python.ast"><span class="typeNameLink">Next Class</span></a></li>
</ul>
<ul class="navList">
<li><a href="../../../../../../index.html?net/sourceforge/pmd/lang/python/ast/<API key>.html" target="_top">Frames</a></li>
<li><a href="<API key>.html" target="_top">No Frames</a></li>
</ul>
<ul class="navList" id="<API key>">
<li><a href="../../../../../../allclasses-noframe.html">All Classes</a></li>
</ul>
<div>
<script type="text/javascript"><!
allClassesLink = document.getElementById("<API key>");
if(window==top) {
allClassesLink.style.display = "block";
}
else {
allClassesLink.style.display = "none";
}
</script>
</div>
<div>
<ul class="subNavList">
<li>Summary: </li>
<li>Nested | </li>
<li><a href="#field.summary">Field</a> | </li>
<li>Constr | </li>
<li>Method</li>
</ul>
<ul class="subNavList">
<li>Detail: </li>
<li><a href="#field.detail">Field</a> | </li>
<li>Constr | </li>
<li>Method</li>
</ul>
</div>
<a name="skip.navbar.top">
</a></div>
<div class="header">
<div class="subTitle">net.sourceforge.pmd.lang.python.ast</div>
<h2 title="Interface <API key>" class="title">Interface <API key></h2>
</div>
<div class="contentContainer">
<div class="description">
<ul class="blockList">
<li class="blockList">
<dl>
<dt>All Known Implementing Classes:</dt>
<dd><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html" title="class in net.sourceforge.pmd.lang.python.ast"><API key></a></dd>
</dl>
<hr>
<br>
<pre>public interface <span class="typeNameLabel"><API key></span></pre>
<div class="block">Token literal values and constants.
Generated by org.javacc.parser.OtherFilesGen#start()</div>
</li>
</ul>
</div>
<div class="summary">
<ul class="blockList">
<li class="blockList">
<ul class="blockList">
<li class="blockList"><a name="field.summary">
</a>
<h3>Field Summary</h3>
<table class="memberSummary" border="0" cellpadding="3" cellspacing="0" summary="Field Summary table, listing fields, and an explanation">
<caption><span>Fields</span><span class="tabEnd"> </span></caption>
<tr>
<th class="colFirst" scope="col">Modifier and Type</th>
<th class="colLast" scope="col">Field and Description</th>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#AND">AND</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#AND_BOOL">AND_BOOL</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#ANDEQ">ANDEQ</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#AS">AS</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#ASSERT">ASSERT</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#AT">AT</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#BINNUMBER">BINNUMBER</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#BREAK">BREAK</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#CLASS">CLASS</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#COLON">COLON</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#COMMA">COMMA</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#COMPLEX">COMPLEX</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#CONTINUATION">CONTINUATION</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#CONTINUE">CONTINUE</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#DECNUMBER">DECNUMBER</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#DEF">DEF</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#DEFAULT">DEFAULT</a></span></code>
<div class="block">Lexical state.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#DEL">DEL</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#DIGIT">DIGIT</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#DIVIDE">DIVIDE</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#DIVIDEEQ">DIVIDEEQ</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#DOT">DOT</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#ELIF">ELIF</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#ELSE">ELSE</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#EOF">EOF</a></span></code>
<div class="block">End of File.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#EQEQUAL">EQEQUAL</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#EQGREATER">EQGREATER</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#EQLESS">EQLESS</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#EQUAL">EQUAL</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#EXCEPT">EXCEPT</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#EXEC">EXEC</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#EXPONENT">EXPONENT</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#FINALLY">FINALLY</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#FLOAT">FLOAT</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#FLOORDIVIDE">FLOORDIVIDE</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#FLOORDIVIDEEQ">FLOORDIVIDEEQ</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#FOR">FOR</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#FROM">FROM</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#GLOBAL">GLOBAL</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#GREATER">GREATER</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#HEXNUMBER">HEXNUMBER</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#IF">IF</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#IMPORT">IMPORT</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#IN">IN</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#IN_BSTRING11">IN_BSTRING11</a></span></code>
<div class="block">Lexical state.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#IN_BSTRING13">IN_BSTRING13</a></span></code>
<div class="block">Lexical state.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#IN_BSTRING1NLC">IN_BSTRING1NLC</a></span></code>
<div class="block">Lexical state.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#IN_BSTRING21">IN_BSTRING21</a></span></code>
<div class="block">Lexical state.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#IN_BSTRING23">IN_BSTRING23</a></span></code>
<div class="block">Lexical state.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#IN_BSTRING2NLC">IN_BSTRING2NLC</a></span></code>
<div class="block">Lexical state.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#IN_STRING11">IN_STRING11</a></span></code>
<div class="block">Lexical state.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#IN_STRING13">IN_STRING13</a></span></code>
<div class="block">Lexical state.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#IN_STRING1NLC">IN_STRING1NLC</a></span></code>
<div class="block">Lexical state.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#IN_STRING21">IN_STRING21</a></span></code>
<div class="block">Lexical state.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#IN_STRING23">IN_STRING23</a></span></code>
<div class="block">Lexical state.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#IN_STRING2NLC">IN_STRING2NLC</a></span></code>
<div class="block">Lexical state.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#IN_USTRING11">IN_USTRING11</a></span></code>
<div class="block">Lexical state.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#IN_USTRING13">IN_USTRING13</a></span></code>
<div class="block">Lexical state.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#IN_USTRING1NLC">IN_USTRING1NLC</a></span></code>
<div class="block">Lexical state.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#IN_USTRING21">IN_USTRING21</a></span></code>
<div class="block">Lexical state.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#IN_USTRING23">IN_USTRING23</a></span></code>
<div class="block">Lexical state.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#IN_USTRING2NLC">IN_USTRING2NLC</a></span></code>
<div class="block">Lexical state.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#IS">IS</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#LAMBDA">LAMBDA</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#LBRACE">LBRACE</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#LBRACKET">LBRACKET</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#LESS">LESS</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#LESSGREATER">LESSGREATER</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#LETTER">LETTER</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#LPAREN">LPAREN</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#LSHIFT">LSHIFT</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#LSHIFTEQ">LSHIFTEQ</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#MINUS">MINUS</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#MINUSEQ">MINUSEQ</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#MODULO">MODULO</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#MODULOEQ">MODULOEQ</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#MULTIPLY">MULTIPLY</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#MULTIPLYEQ">MULTIPLYEQ</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#NAME">NAME</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#NEWLINE">NEWLINE</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#NOT">NOT</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#NOT_BOOL">NOT_BOOL</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#NOTEQUAL">NOTEQUAL</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#OCTNUMBER">OCTNUMBER</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#OR">OR</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#OR_BOOL">OR_BOOL</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#OREQ">OREQ</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#PASS">PASS</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#PLUS">PLUS</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#PLUSEQ">PLUSEQ</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#POWER">POWER</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#POWEREQ">POWEREQ</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#PRINT">PRINT</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#RAISE">RAISE</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#RBRACE">RBRACE</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#RBRACKET">RBRACKET</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#RETURN">RETURN</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#RPAREN">RPAREN</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#RSHIFT">RSHIFT</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#RSHIFTEQ">RSHIFTEQ</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#SEMICOLON">SEMICOLON</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#SINGLE_BSTRING">SINGLE_BSTRING</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#SINGLE_BSTRING2">SINGLE_BSTRING2</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#SINGLE_STRING">SINGLE_STRING</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#SINGLE_STRING2">SINGLE_STRING2</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#SINGLE_USTRING">SINGLE_USTRING</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#SINGLE_USTRING2">SINGLE_USTRING2</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#SPACE">SPACE</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>[]</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#tokenImage">tokenImage</a></span></code>
<div class="block">Literal token values.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#TRAILING_COMMENT">TRAILING_COMMENT</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#TRIPLE_BSTRING">TRIPLE_BSTRING</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#TRIPLE_BSTRING2">TRIPLE_BSTRING2</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#TRIPLE_STRING">TRIPLE_STRING</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#TRIPLE_STRING2">TRIPLE_STRING2</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#TRIPLE_USTRING">TRIPLE_USTRING</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#TRIPLE_USTRING2">TRIPLE_USTRING2</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#TRY">TRY</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#WHILE">WHILE</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#WITH">WITH</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#XOR">XOR</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#XOREQ">XOREQ</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html#YIELD">YIELD</a></span></code>
<div class="block">RegularExpression Id.</div>
</td>
</tr>
</table>
</li>
</ul>
</li>
</ul>
</div>
<div class="details">
<ul class="blockList">
<li class="blockList">
<ul class="blockList">
<li class="blockList"><a name="field.detail">
</a>
<h3>Field Detail</h3>
<a name="EOF">
</a>
<ul class="blockList">
<li class="blockList">
<h4>EOF</h4>
<pre>static final int EOF</pre>
<div class="block">End of File.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.EOF">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="SPACE">
</a>
<ul class="blockList">
<li class="blockList">
<h4>SPACE</h4>
<pre>static final int SPACE</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.SPACE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="CONTINUATION">
</a>
<ul class="blockList">
<li class="blockList">
<h4>CONTINUATION</h4>
<pre>static final int CONTINUATION</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.CONTINUATION">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="NEWLINE">
</a>
<ul class="blockList">
<li class="blockList">
<h4>NEWLINE</h4>
<pre>static final int NEWLINE</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.NEWLINE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TRAILING_COMMENT">
</a>
<ul class="blockList">
<li class="blockList">
<h4>TRAILING_COMMENT</h4>
<pre>static final int TRAILING_COMMENT</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.TRAILING_COMMENT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="LPAREN">
</a>
<ul class="blockList">
<li class="blockList">
<h4>LPAREN</h4>
<pre>static final int LPAREN</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.LPAREN">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="RPAREN">
</a>
<ul class="blockList">
<li class="blockList">
<h4>RPAREN</h4>
<pre>static final int RPAREN</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.RPAREN">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="LBRACE">
</a>
<ul class="blockList">
<li class="blockList">
<h4>LBRACE</h4>
<pre>static final int LBRACE</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.LBRACE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="RBRACE">
</a>
<ul class="blockList">
<li class="blockList">
<h4>RBRACE</h4>
<pre>static final int RBRACE</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.RBRACE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="LBRACKET">
</a>
<ul class="blockList">
<li class="blockList">
<h4>LBRACKET</h4>
<pre>static final int LBRACKET</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.LBRACKET">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="RBRACKET">
</a>
<ul class="blockList">
<li class="blockList">
<h4>RBRACKET</h4>
<pre>static final int RBRACKET</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.RBRACKET">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="SEMICOLON">
</a>
<ul class="blockList">
<li class="blockList">
<h4>SEMICOLON</h4>
<pre>static final int SEMICOLON</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.SEMICOLON">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="COMMA">
</a>
<ul class="blockList">
<li class="blockList">
<h4>COMMA</h4>
<pre>static final int COMMA</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.COMMA">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="DOT">
</a>
<ul class="blockList">
<li class="blockList">
<h4>DOT</h4>
<pre>static final int DOT</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.DOT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="COLON">
</a>
<ul class="blockList">
<li class="blockList">
<h4>COLON</h4>
<pre>static final int COLON</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.COLON">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="PLUS">
</a>
<ul class="blockList">
<li class="blockList">
<h4>PLUS</h4>
<pre>static final int PLUS</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.PLUS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="MINUS">
</a>
<ul class="blockList">
<li class="blockList">
<h4>MINUS</h4>
<pre>static final int MINUS</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.MINUS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="MULTIPLY">
</a>
<ul class="blockList">
<li class="blockList">
<h4>MULTIPLY</h4>
<pre>static final int MULTIPLY</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.MULTIPLY">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="DIVIDE">
</a>
<ul class="blockList">
<li class="blockList">
<h4>DIVIDE</h4>
<pre>static final int DIVIDE</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.DIVIDE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="FLOORDIVIDE">
</a>
<ul class="blockList">
<li class="blockList">
<h4>FLOORDIVIDE</h4>
<pre>static final int FLOORDIVIDE</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.FLOORDIVIDE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="POWER">
</a>
<ul class="blockList">
<li class="blockList">
<h4>POWER</h4>
<pre>static final int POWER</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.POWER">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="LSHIFT">
</a>
<ul class="blockList">
<li class="blockList">
<h4>LSHIFT</h4>
<pre>static final int LSHIFT</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.LSHIFT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="RSHIFT">
</a>
<ul class="blockList">
<li class="blockList">
<h4>RSHIFT</h4>
<pre>static final int RSHIFT</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.RSHIFT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="MODULO">
</a>
<ul class="blockList">
<li class="blockList">
<h4>MODULO</h4>
<pre>static final int MODULO</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.MODULO">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="NOT">
</a>
<ul class="blockList">
<li class="blockList">
<h4>NOT</h4>
<pre>static final int NOT</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.NOT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="XOR">
</a>
<ul class="blockList">
<li class="blockList">
<h4>XOR</h4>
<pre>static final int XOR</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.XOR">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="OR">
</a>
<ul class="blockList">
<li class="blockList">
<h4>OR</h4>
<pre>static final int OR</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.OR">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="AND">
</a>
<ul class="blockList">
<li class="blockList">
<h4>AND</h4>
<pre>static final int AND</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.AND">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="EQUAL">
</a>
<ul class="blockList">
<li class="blockList">
<h4>EQUAL</h4>
<pre>static final int EQUAL</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.EQUAL">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="GREATER">
</a>
<ul class="blockList">
<li class="blockList">
<h4>GREATER</h4>
<pre>static final int GREATER</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.GREATER">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="LESS">
</a>
<ul class="blockList">
<li class="blockList">
<h4>LESS</h4>
<pre>static final int LESS</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.LESS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="EQEQUAL">
</a>
<ul class="blockList">
<li class="blockList">
<h4>EQEQUAL</h4>
<pre>static final int EQEQUAL</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.EQEQUAL">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="EQLESS">
</a>
<ul class="blockList">
<li class="blockList">
<h4>EQLESS</h4>
<pre>static final int EQLESS</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.EQLESS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="EQGREATER">
</a>
<ul class="blockList">
<li class="blockList">
<h4>EQGREATER</h4>
<pre>static final int EQGREATER</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.EQGREATER">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="LESSGREATER">
</a>
<ul class="blockList">
<li class="blockList">
<h4>LESSGREATER</h4>
<pre>static final int LESSGREATER</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.LESSGREATER">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="NOTEQUAL">
</a>
<ul class="blockList">
<li class="blockList">
<h4>NOTEQUAL</h4>
<pre>static final int NOTEQUAL</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.NOTEQUAL">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="PLUSEQ">
</a>
<ul class="blockList">
<li class="blockList">
<h4>PLUSEQ</h4>
<pre>static final int PLUSEQ</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.PLUSEQ">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="MINUSEQ">
</a>
<ul class="blockList">
<li class="blockList">
<h4>MINUSEQ</h4>
<pre>static final int MINUSEQ</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.MINUSEQ">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="MULTIPLYEQ">
</a>
<ul class="blockList">
<li class="blockList">
<h4>MULTIPLYEQ</h4>
<pre>static final int MULTIPLYEQ</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.MULTIPLYEQ">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="DIVIDEEQ">
</a>
<ul class="blockList">
<li class="blockList">
<h4>DIVIDEEQ</h4>
<pre>static final int DIVIDEEQ</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.DIVIDEEQ">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="FLOORDIVIDEEQ">
</a>
<ul class="blockList">
<li class="blockList">
<h4>FLOORDIVIDEEQ</h4>
<pre>static final int FLOORDIVIDEEQ</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.FLOORDIVIDEEQ">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="MODULOEQ">
</a>
<ul class="blockList">
<li class="blockList">
<h4>MODULOEQ</h4>
<pre>static final int MODULOEQ</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.MODULOEQ">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="ANDEQ">
</a>
<ul class="blockList">
<li class="blockList">
<h4>ANDEQ</h4>
<pre>static final int ANDEQ</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.ANDEQ">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="OREQ">
</a>
<ul class="blockList">
<li class="blockList">
<h4>OREQ</h4>
<pre>static final int OREQ</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.OREQ">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="XOREQ">
</a>
<ul class="blockList">
<li class="blockList">
<h4>XOREQ</h4>
<pre>static final int XOREQ</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.XOREQ">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="LSHIFTEQ">
</a>
<ul class="blockList">
<li class="blockList">
<h4>LSHIFTEQ</h4>
<pre>static final int LSHIFTEQ</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.LSHIFTEQ">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="RSHIFTEQ">
</a>
<ul class="blockList">
<li class="blockList">
<h4>RSHIFTEQ</h4>
<pre>static final int RSHIFTEQ</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.RSHIFTEQ">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="POWEREQ">
</a>
<ul class="blockList">
<li class="blockList">
<h4>POWEREQ</h4>
<pre>static final int POWEREQ</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.POWEREQ">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="OR_BOOL">
</a>
<ul class="blockList">
<li class="blockList">
<h4>OR_BOOL</h4>
<pre>static final int OR_BOOL</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.OR_BOOL">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="AND_BOOL">
</a>
<ul class="blockList">
<li class="blockList">
<h4>AND_BOOL</h4>
<pre>static final int AND_BOOL</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.AND_BOOL">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="NOT_BOOL">
</a>
<ul class="blockList">
<li class="blockList">
<h4>NOT_BOOL</h4>
<pre>static final int NOT_BOOL</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.NOT_BOOL">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IS">
</a>
<ul class="blockList">
<li class="blockList">
<h4>IS</h4>
<pre>static final int IS</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.IS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IN">
</a>
<ul class="blockList">
<li class="blockList">
<h4>IN</h4>
<pre>static final int IN</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.IN">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="LAMBDA">
</a>
<ul class="blockList">
<li class="blockList">
<h4>LAMBDA</h4>
<pre>static final int LAMBDA</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.LAMBDA">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IF">
</a>
<ul class="blockList">
<li class="blockList">
<h4>IF</h4>
<pre>static final int IF</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.IF">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="ELSE">
</a>
<ul class="blockList">
<li class="blockList">
<h4>ELSE</h4>
<pre>static final int ELSE</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.ELSE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="ELIF">
</a>
<ul class="blockList">
<li class="blockList">
<h4>ELIF</h4>
<pre>static final int ELIF</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.ELIF">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="WHILE">
</a>
<ul class="blockList">
<li class="blockList">
<h4>WHILE</h4>
<pre>static final int WHILE</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.WHILE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="FOR">
</a>
<ul class="blockList">
<li class="blockList">
<h4>FOR</h4>
<pre>static final int FOR</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.FOR">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TRY">
</a>
<ul class="blockList">
<li class="blockList">
<h4>TRY</h4>
<pre>static final int TRY</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.TRY">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="EXCEPT">
</a>
<ul class="blockList">
<li class="blockList">
<h4>EXCEPT</h4>
<pre>static final int EXCEPT</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.EXCEPT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="DEF">
</a>
<ul class="blockList">
<li class="blockList">
<h4>DEF</h4>
<pre>static final int DEF</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.DEF">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="CLASS">
</a>
<ul class="blockList">
<li class="blockList">
<h4>CLASS</h4>
<pre>static final int CLASS</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.CLASS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="FINALLY">
</a>
<ul class="blockList">
<li class="blockList">
<h4>FINALLY</h4>
<pre>static final int FINALLY</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.FINALLY">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="PRINT">
</a>
<ul class="blockList">
<li class="blockList">
<h4>PRINT</h4>
<pre>static final int PRINT</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.PRINT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="PASS">
</a>
<ul class="blockList">
<li class="blockList">
<h4>PASS</h4>
<pre>static final int PASS</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.PASS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="BREAK">
</a>
<ul class="blockList">
<li class="blockList">
<h4>BREAK</h4>
<pre>static final int BREAK</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.BREAK">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="CONTINUE">
</a>
<ul class="blockList">
<li class="blockList">
<h4>CONTINUE</h4>
<pre>static final int CONTINUE</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.CONTINUE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="RETURN">
</a>
<ul class="blockList">
<li class="blockList">
<h4>RETURN</h4>
<pre>static final int RETURN</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.RETURN">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="YIELD">
</a>
<ul class="blockList">
<li class="blockList">
<h4>YIELD</h4>
<pre>static final int YIELD</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.YIELD">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IMPORT">
</a>
<ul class="blockList">
<li class="blockList">
<h4>IMPORT</h4>
<pre>static final int IMPORT</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.IMPORT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="FROM">
</a>
<ul class="blockList">
<li class="blockList">
<h4>FROM</h4>
<pre>static final int FROM</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.FROM">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="DEL">
</a>
<ul class="blockList">
<li class="blockList">
<h4>DEL</h4>
<pre>static final int DEL</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.DEL">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="RAISE">
</a>
<ul class="blockList">
<li class="blockList">
<h4>RAISE</h4>
<pre>static final int RAISE</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.RAISE">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="GLOBAL">
</a>
<ul class="blockList">
<li class="blockList">
<h4>GLOBAL</h4>
<pre>static final int GLOBAL</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.GLOBAL">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="EXEC">
</a>
<ul class="blockList">
<li class="blockList">
<h4>EXEC</h4>
<pre>static final int EXEC</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.EXEC">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="ASSERT">
</a>
<ul class="blockList">
<li class="blockList">
<h4>ASSERT</h4>
<pre>static final int ASSERT</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.ASSERT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="AS">
</a>
<ul class="blockList">
<li class="blockList">
<h4>AS</h4>
<pre>static final int AS</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.AS">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="WITH">
</a>
<ul class="blockList">
<li class="blockList">
<h4>WITH</h4>
<pre>static final int WITH</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.WITH">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="AT">
</a>
<ul class="blockList">
<li class="blockList">
<h4>AT</h4>
<pre>static final int AT</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.AT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="NAME">
</a>
<ul class="blockList">
<li class="blockList">
<h4>NAME</h4>
<pre>static final int NAME</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.NAME">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="LETTER">
</a>
<ul class="blockList">
<li class="blockList">
<h4>LETTER</h4>
<pre>static final int LETTER</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.LETTER">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="DECNUMBER">
</a>
<ul class="blockList">
<li class="blockList">
<h4>DECNUMBER</h4>
<pre>static final int DECNUMBER</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.DECNUMBER">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="HEXNUMBER">
</a>
<ul class="blockList">
<li class="blockList">
<h4>HEXNUMBER</h4>
<pre>static final int HEXNUMBER</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.HEXNUMBER">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="OCTNUMBER">
</a>
<ul class="blockList">
<li class="blockList">
<h4>OCTNUMBER</h4>
<pre>static final int OCTNUMBER</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.OCTNUMBER">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="BINNUMBER">
</a>
<ul class="blockList">
<li class="blockList">
<h4>BINNUMBER</h4>
<pre>static final int BINNUMBER</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.BINNUMBER">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="FLOAT">
</a>
<ul class="blockList">
<li class="blockList">
<h4>FLOAT</h4>
<pre>static final int FLOAT</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.FLOAT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="COMPLEX">
</a>
<ul class="blockList">
<li class="blockList">
<h4>COMPLEX</h4>
<pre>static final int COMPLEX</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.COMPLEX">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="EXPONENT">
</a>
<ul class="blockList">
<li class="blockList">
<h4>EXPONENT</h4>
<pre>static final int EXPONENT</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.EXPONENT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="DIGIT">
</a>
<ul class="blockList">
<li class="blockList">
<h4>DIGIT</h4>
<pre>static final int DIGIT</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.DIGIT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="SINGLE_STRING">
</a>
<ul class="blockList">
<li class="blockList">
<h4>SINGLE_STRING</h4>
<pre>static final int SINGLE_STRING</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.SINGLE_STRING">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="SINGLE_STRING2">
</a>
<ul class="blockList">
<li class="blockList">
<h4>SINGLE_STRING2</h4>
<pre>static final int SINGLE_STRING2</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.SINGLE_STRING2">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TRIPLE_STRING">
</a>
<ul class="blockList">
<li class="blockList">
<h4>TRIPLE_STRING</h4>
<pre>static final int TRIPLE_STRING</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.TRIPLE_STRING">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TRIPLE_STRING2">
</a>
<ul class="blockList">
<li class="blockList">
<h4>TRIPLE_STRING2</h4>
<pre>static final int TRIPLE_STRING2</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.TRIPLE_STRING2">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="SINGLE_BSTRING">
</a>
<ul class="blockList">
<li class="blockList">
<h4>SINGLE_BSTRING</h4>
<pre>static final int SINGLE_BSTRING</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.SINGLE_BSTRING">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="SINGLE_BSTRING2">
</a>
<ul class="blockList">
<li class="blockList">
<h4>SINGLE_BSTRING2</h4>
<pre>static final int SINGLE_BSTRING2</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.SINGLE_BSTRING2">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TRIPLE_BSTRING">
</a>
<ul class="blockList">
<li class="blockList">
<h4>TRIPLE_BSTRING</h4>
<pre>static final int TRIPLE_BSTRING</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.TRIPLE_BSTRING">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TRIPLE_BSTRING2">
</a>
<ul class="blockList">
<li class="blockList">
<h4>TRIPLE_BSTRING2</h4>
<pre>static final int TRIPLE_BSTRING2</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.TRIPLE_BSTRING2">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="SINGLE_USTRING">
</a>
<ul class="blockList">
<li class="blockList">
<h4>SINGLE_USTRING</h4>
<pre>static final int SINGLE_USTRING</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.SINGLE_USTRING">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="SINGLE_USTRING2">
</a>
<ul class="blockList">
<li class="blockList">
<h4>SINGLE_USTRING2</h4>
<pre>static final int SINGLE_USTRING2</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.SINGLE_USTRING2">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TRIPLE_USTRING">
</a>
<ul class="blockList">
<li class="blockList">
<h4>TRIPLE_USTRING</h4>
<pre>static final int TRIPLE_USTRING</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.TRIPLE_USTRING">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="TRIPLE_USTRING2">
</a>
<ul class="blockList">
<li class="blockList">
<h4>TRIPLE_USTRING2</h4>
<pre>static final int TRIPLE_USTRING2</pre>
<div class="block">RegularExpression Id.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.TRIPLE_USTRING2">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="DEFAULT">
</a>
<ul class="blockList">
<li class="blockList">
<h4>DEFAULT</h4>
<pre>static final int DEFAULT</pre>
<div class="block">Lexical state.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.DEFAULT">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IN_STRING11">
</a>
<ul class="blockList">
<li class="blockList">
<h4>IN_STRING11</h4>
<pre>static final int IN_STRING11</pre>
<div class="block">Lexical state.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.IN_STRING11">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IN_STRING21">
</a>
<ul class="blockList">
<li class="blockList">
<h4>IN_STRING21</h4>
<pre>static final int IN_STRING21</pre>
<div class="block">Lexical state.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.IN_STRING21">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IN_STRING13">
</a>
<ul class="blockList">
<li class="blockList">
<h4>IN_STRING13</h4>
<pre>static final int IN_STRING13</pre>
<div class="block">Lexical state.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.IN_STRING13">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IN_STRING23">
</a>
<ul class="blockList">
<li class="blockList">
<h4>IN_STRING23</h4>
<pre>static final int IN_STRING23</pre>
<div class="block">Lexical state.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.IN_STRING23">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IN_BSTRING11">
</a>
<ul class="blockList">
<li class="blockList">
<h4>IN_BSTRING11</h4>
<pre>static final int IN_BSTRING11</pre>
<div class="block">Lexical state.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.IN_BSTRING11">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IN_BSTRING21">
</a>
<ul class="blockList">
<li class="blockList">
<h4>IN_BSTRING21</h4>
<pre>static final int IN_BSTRING21</pre>
<div class="block">Lexical state.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.IN_BSTRING21">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IN_BSTRING13">
</a>
<ul class="blockList">
<li class="blockList">
<h4>IN_BSTRING13</h4>
<pre>static final int IN_BSTRING13</pre>
<div class="block">Lexical state.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.IN_BSTRING13">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IN_BSTRING23">
</a>
<ul class="blockList">
<li class="blockList">
<h4>IN_BSTRING23</h4>
<pre>static final int IN_BSTRING23</pre>
<div class="block">Lexical state.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.IN_BSTRING23">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IN_USTRING11">
</a>
<ul class="blockList">
<li class="blockList">
<h4>IN_USTRING11</h4>
<pre>static final int IN_USTRING11</pre>
<div class="block">Lexical state.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.IN_USTRING11">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IN_USTRING21">
</a>
<ul class="blockList">
<li class="blockList">
<h4>IN_USTRING21</h4>
<pre>static final int IN_USTRING21</pre>
<div class="block">Lexical state.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.IN_USTRING21">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IN_USTRING13">
</a>
<ul class="blockList">
<li class="blockList">
<h4>IN_USTRING13</h4>
<pre>static final int IN_USTRING13</pre>
<div class="block">Lexical state.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.IN_USTRING13">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IN_USTRING23">
</a>
<ul class="blockList">
<li class="blockList">
<h4>IN_USTRING23</h4>
<pre>static final int IN_USTRING23</pre>
<div class="block">Lexical state.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.IN_USTRING23">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IN_STRING1NLC">
</a>
<ul class="blockList">
<li class="blockList">
<h4>IN_STRING1NLC</h4>
<pre>static final int IN_STRING1NLC</pre>
<div class="block">Lexical state.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.IN_STRING1NLC">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IN_STRING2NLC">
</a>
<ul class="blockList">
<li class="blockList">
<h4>IN_STRING2NLC</h4>
<pre>static final int IN_STRING2NLC</pre>
<div class="block">Lexical state.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.IN_STRING2NLC">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IN_USTRING1NLC">
</a>
<ul class="blockList">
<li class="blockList">
<h4>IN_USTRING1NLC</h4>
<pre>static final int IN_USTRING1NLC</pre>
<div class="block">Lexical state.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.IN_USTRING1NLC">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IN_USTRING2NLC">
</a>
<ul class="blockList">
<li class="blockList">
<h4>IN_USTRING2NLC</h4>
<pre>static final int IN_USTRING2NLC</pre>
<div class="block">Lexical state.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.IN_USTRING2NLC">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IN_BSTRING1NLC">
</a>
<ul class="blockList">
<li class="blockList">
<h4>IN_BSTRING1NLC</h4>
<pre>static final int IN_BSTRING1NLC</pre>
<div class="block">Lexical state.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.IN_BSTRING1NLC">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="IN_BSTRING2NLC">
</a>
<ul class="blockList">
<li class="blockList">
<h4>IN_BSTRING2NLC</h4>
<pre>static final int IN_BSTRING2NLC</pre>
<div class="block">Lexical state.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../constant-values.html#net.sourceforge.pmd.lang.python.ast.<API key>.IN_BSTRING2NLC">Constant Field Values</a></dd>
</dl>
</li>
</ul>
<a name="tokenImage">
</a>
<ul class="blockListLast">
<li class="blockList">
<h4>tokenImage</h4>
<pre>static final <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>[] tokenImage</pre>
<div class="block">Literal token values.</div>
</li>
</ul>
</li>
</ul>
</li>
</ul>
</div>
</div>
<div class="bottomNav"><a name="navbar.bottom">
</a>
<div class="skipNav"><a href="#skip.navbar.bottom" title="Skip navigation links">Skip navigation links</a></div>
<a name="navbar.bottom.firstrow">
</a>
<ul class="navList" title="Navigation">
<li><a href="../../../../../../overview-summary.html">Overview</a></li>
<li><a href="package-summary.html">Package</a></li>
<li class="navBarCell1Rev">Class</li>
<li><a href="class-use/<API key>.html">Use</a></li>
<li><a href="package-tree.html">Tree</a></li>
<li><a href="../../../../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../../../../index-all.html">Index</a></li>
<li><a href="../../../../../../help-doc.html">Help</a></li>
</ul>
</div>
<div class="subNav">
<ul class="navList">
<li>Prev Class</li>
<li><a href="../../../../../../net/sourceforge/pmd/lang/python/ast/<API key>.html" title="class in net.sourceforge.pmd.lang.python.ast"><span class="typeNameLink">Next Class</span></a></li>
</ul>
<ul class="navList">
<li><a href="../../../../../../index.html?net/sourceforge/pmd/lang/python/ast/<API key>.html" target="_top">Frames</a></li>
<li><a href="<API key>.html" target="_top">No Frames</a></li>
</ul>
<ul class="navList" id="<API key>">
<li><a href="../../../../../../allclasses-noframe.html">All Classes</a></li>
</ul>
<div>
<script type="text/javascript"><!
allClassesLink = document.getElementById("<API key>");
if(window==top) {
allClassesLink.style.display = "block";
}
else {
allClassesLink.style.display = "none";
}
</script>
</div>
<div>
<ul class="subNavList">
<li>Summary: </li>
<li>Nested | </li>
<li><a href="#field.summary">Field</a> | </li>
<li>Constr | </li>
<li>Method</li>
</ul>
<ul class="subNavList">
<li>Detail: </li>
<li><a href="#field.detail">Field</a> | </li>
<li>Constr | </li>
<li>Method</li>
</ul>
</div>
<a name="skip.navbar.bottom">
</a></div>
<p class="legalCopy"><small>Copyright &
</body>
</html>
|
<?php
namespace Slime;
use Illuminate\Database\Eloquent\Model;
class Persona extends Model
{
protected $table = "Persona";
protected $fillable = ['nombre','apellido','Cargo_id'];
}
|
<template name="ListStudent">
{{#IfLoggedIn}}
<div class="row" style="background-image: url('/images/textbookheader.png'); background-size: cover;">
<div class="col-md-10">
<div class="bumper">
<table class="table table-hover" style="background-color: white; border-top: 5px solid #00AFDD;">
<thead>
<tr>
<th>First</th>
<th>Last</th>
<th>Email</th>
<th></th>
</tr>
</thead>
<tbody>
{{#each studentList}}
<tr>
<td>{{first}}</td>
<td>{{last}}</td>
<td>{{email}}</td>
<td><a class="deletestudent button1" style="font-size: 10px" href="#">BAN</a></td>
</tr>
{{/each}}
</tbody>
</table>
</div>
</div>
<div class="col-md-2" style="background-color: rgba(250,250,250,0.7);">
<div class="bumper">
<div class="matchbox">
<h1 style="text-align: center; padding-bottom: 10px;">BANNED STUDENTS</h1>
</div>
<table class="table table-hover" style="background-color: white; border-top: 5px solid #00AFDD;">
<thead>
<tr>
<th>Email</th>
<th></th>
</tr>
</thead>
<tbody>
{{#each banList}}
<tr>
<td>{{email}}</td>
<td><a class="unban button1" style="font-size: 10px" href="#">UNBAN</a></td>
</tr>
{{/each}}
</tbody>
</table>
</div>
</div>
</div>
{{/IfLoggedIn}}
</template>
|
<?php
// autoload_namespaces.php @generated by Composer
$vendorDir = dirname(dirname(__FILE__));
$baseDir = dirname($vendorDir);
return array(
'Twig_' => array($vendorDir . '/twig/twig/lib'),
'Symfony\\Component\\Icu\\' => array($vendorDir . '/symfony/icu'),
'Symfony\\Bundle\\SwiftmailerBundle' => array($vendorDir . '/symfony/swiftmailer-bundle'),
'Symfony\\Bundle\\MonologBundle' => array($vendorDir . '/symfony/monolog-bundle'),
'Symfony\\Bundle\\AsseticBundle' => array($vendorDir . '/symfony/assetic-bundle'),
'Symfony\\' => array($vendorDir . '/symfony/symfony/src'),
'Sensio\\Bundle\\GeneratorBundle' => array($vendorDir . '/sensio/generator-bundle'),
'Sensio\\Bundle\\<API key>' => array($vendorDir . '/sensio/<API key>'),
'Sensio\\Bundle\\DistributionBundle' => array($vendorDir . '/sensio/distribution-bundle'),
'Psr\\Log\\' => array($vendorDir . '/psr/log'),
'PHPExcel' => array($vendorDir . '/phpoffice/phpexcel/Classes'),
'Gregwar\\CaptchaBundle' => array($vendorDir . '/gregwar/captcha-bundle'),
'Gregwar\\Captcha' => array($vendorDir . '/gregwar/captcha'),
'Doctrine\\ORM\\' => array($vendorDir . '/doctrine/orm/lib'),
'Doctrine\\DBAL\\' => array($vendorDir . '/doctrine/dbal/lib'),
'Doctrine\\Common\\Lexer\\' => array($vendorDir . '/doctrine/lexer/lib'),
'Doctrine\\Common\\Inflector\\' => array($vendorDir . '/doctrine/inflector/lib'),
'Doctrine\\Common\\Collections\\' => array($vendorDir . '/doctrine/collections/lib'),
'Doctrine\\Common\\Cache\\' => array($vendorDir . '/doctrine/cache/lib'),
'Doctrine\\Common\\Annotations\\' => array($vendorDir . '/doctrine/annotations/lib'),
'Doctrine\\Common\\' => array($vendorDir . '/doctrine/common/lib'),
'Doctrine\\Bundle\\DoctrineBundle' => array($vendorDir . '/doctrine/doctrine-bundle'),
'Assetic' => array($vendorDir . '/kriswallsmith/assetic/src'),
array($baseDir . '/src')
);
|
<?php
function geoip($dbipcsv, $ip){
$csvData = file_get_contents("/lib/".$dbipcsv);
$lines = explode(PHP_EOL, $csvData);
$rangeArray = array();
foreach ($lines as $line) {
$rangeArray[] = str_getcsv($line);
}
$input = $ip;
$array_input = explode(".", $input);
foreach($rangeArray as $current)
{
$array_start = explode(".", $current['0']);
$array_stop = explode(".", $current['1']);
if((int)$array_input[0] >= (int)$array_start[0]){
if((int)$array_input[0] <= (int)$array_stop[0]){
if((int)$array_input[1] >= (int)$array_start[1]){
if((int)$array_input[1] <= (int)$array_stop[1]){
if((int)$array_input[2] >= (int)$array_start[2]){
if((int)$array_input[2] <= (int)$array_stop[2]){
if((int)$array_input[3] >= (int)$array_start[3]){
if((int)$array_input[3] <= (int)$array_stop[3]){
$data = $current[2];
}
}
}
}
}
}
}
}
}
return $data;
}
?>
|
# Contributing to SlicerITKUltrasound
Contributions are welcome and encouraged.
To contribute, create a pull request on the [project's GitHub
repository](https://github.com/KitwareMedical/SlicerITKUltrasound).
Respectful and collaborative discourse is appreciated and expected.
Please patiently address all automated builds and review comments.
For more information how to use the Git version control system, see the
excellent [ProGit
book](https://git-scm.com/book/en/v2/<API key>). This
repository uses common GitHub practices, sometimes referred to as the [GitHub
flow](https://help.github.com/articles/github-flow/).
|
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>ttt</title>
<link rel="stylesheet" href="style.css">
</head>
<body>
<div>
<form method="post" action="/shop/register">
</form>
</div>
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.3/jquery.min.js"></script>
<script type="text/javascript" src="assets/js/jquery.jcarousellite.js"></script>
<script type="text/javascript" src="assets/js/jquery.cookie.min.js"></script>
<script type="text/javascript" src="assets/js/jquery.validate.js"></script>
<script type="text/javascript" src="assets/js/jquery.form.js"></script>
<script type="text/javascript" src="assets/js/script.js"></script>
<script type="text/javascript" src="assets/js/reg.js"></script>
</body>
</html>
|
#!/usr/bin/env python
"""
This pretty much just tests creating a user, a universe, a planet, a building type name, a building
type, and a building.
"""
import os
import sys
import sqlalchemy
sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
import legendary_waffle
# Database setup
db_engine = sqlalchemy.create_engine("sqlite:
legendary_waffle.models.MODELBASE.metadata.create_all(db_engine)
legendary_waffle.models.MODELBASE.metadata.bind = db_engine
db_session = sqlalchemy.orm.sessionmaker(bind=db_engine)
db = db_session()
# Create the user
legendary_waffle.model_create(db, legendary_waffle.models.User, name='sk4ly')
print "Users: {}".format(legendary_waffle.model_read(db, legendary_waffle.models.User))
# Create the universe
universe_config = {
"name": 'poopiverse',
"map_size": 1000,
"max_planets": 1000,
"max_players": 10
}
legendary_waffle.model_create(db, legendary_waffle.models.Universe, **universe_config)
print "Universe: {}".format(legendary_waffle.model_read(db, legendary_waffle.models.Universe))
# Create the planet
planet_config = {
"universe": 1, # The pkid of the universe 'poopiverse'
"coordinate_x": 1,
"coordinate_y": 1,
"name": 'bloth',
"habitable": True,
"player_control": 1, # The pkid of user 'sk4ly'
"default_condition": 1000,
"default_resources": 1000,
"current_condition": 1000,
"current_resources": 1000
}
legendary_waffle.model_create(db, legendary_waffle.models.Planet, **planet_config)
print "Planet: {}".format(legendary_waffle.model_read(db, legendary_waffle.models.Planet))
# Create building type name
legendary_waffle.model_create(db, legendary_waffle.models.BuildingTypeName, name="Control Center")
print "Building Type Name: {}".format(legendary_waffle.model_read(db, legendary_waffle.models.BuildingTypeName))
# Create building type
<API key> = {
"typename": 1, # The pkid of the building type name 'Control Center'
"description": "This is the control center",
"default_condition": 100,
"default_firepower": 0,
"default_storage": 100,
"rhr_passive": 0,
"rhr_active": 0,
"rhr_destructive": 0,
"build_resource_reqs": 500,
}
legendary_waffle.model_create(db, legendary_waffle.models.BuildingType, **<API key>)
print "Building Type: {}".format(legendary_waffle.model_read(db, legendary_waffle.models.BuildingType))
# Now create our new building
building_config = {
"building_type": 1, # The pkid of the building type with the name 'Control Center'
"universe": 1, # The pkid of the universe 'poopiverse'
"planet": 1, # The pkid of the planet 'bloth'
"player_control": 1, # The pkid of the user 'sk4ly'
}
legendary_waffle.model_create(db, legendary_waffle.models.Building, **building_config)
print "Building: {}".format(legendary_waffle.model_read(db, legendary_waffle.models.Building))
|
<pr-stack-widget options="widget.options" params="widget.params" filters="filters"></pr-stack-widget>
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.