text:
CREATE TABLE list (id VARCHAR(10) NOT NULL, value VARCHAR(64) NOT NULL, PRIMARY KEY(id));

INSERT INTO "list" ("id", "value") VALUES ('AFN', 'Afegani do Afeganistão');
INSERT INTO "list" ("id", "value") VALUES ('AFA', 'Afeghani (1927–2002)');
INSERT INTO "list" ("id", "value") VALUES ('MGA', 'Ariari de Madagáscar');
INSERT INTO "list" ("id", "value") VALUES ('ARA', 'Austral argentino');
INSERT INTO "list" ("id", "value") VALUES ('THB', 'Baht da Tailândia');
INSERT INTO "list" ("id", "value") VALUES ('PAB', 'Balboa do Panamá');
INSERT INTO "list" ("id", "value") VALUES ('ETB', 'Birr etíope');
INSERT INTO "list" ("id", "value") VALUES ('BOB', 'Boliviano');
INSERT INTO "list" ("id", "value") VALUES ('BOL', 'Boliviano (1863–1963)');
INSERT INTO "list" ("id", "value") VALUES ('VEF', 'Bolívar venezuelano');
INSERT INTO "list" ("id", "value") VALUES ('VEB', 'Bolívar venezuelano (1871–2008)');
INSERT INTO "list" ("id", "value") VALUES ('GHS', 'Cedi de Gana');
INSERT INTO "list" ("id", "value") VALUES ('GHC', 'Cedi de Gana (1979–2007)');
INSERT INTO "list" ("id", "value") VALUES ('SVC', 'Colom salvadorenho');
INSERT INTO "list" ("id", "value") VALUES ('CRC', 'Colon costa-riquenho');
INSERT INTO "list" ("id", "value") VALUES ('CSK', 'Coroa Forte checoslovaca');
INSERT INTO "list" ("id", "value") VALUES ('ISJ', 'Coroa antiga islandesa');
INSERT INTO "list" ("id", "value") VALUES ('CZK', 'Coroa checa');
INSERT INTO "list" ("id", "value") VALUES ('DKK', 'Coroa dinamarquesa');
INSERT INTO "list" ("id", "value") VALUES ('SKK', 'Coroa eslovaca');
INSERT INTO "list" ("id", "value") VALUES ('EEK', 'Coroa estoniana');
INSERT INTO "list" ("id", "value") VALUES ('ISK', 'Coroa islandesa');
INSERT INTO "list" ("id", "value") VALUES ('NOK', 'Coroa norueguesa');
INSERT INTO "list" ("id", "value") VALUES ('SEK', 'Coroa sueca');
INSERT INTO "list" ("id", "value") VALUES ('BRC', 'Cruzado brasileiro (1986–1989)');
INSERT INTO "list" ("id", "value") VALUES ('BRN', 'Cruzado novo brasileiro (1989–1990)');
INSERT INTO "list" ("id", "value") VALUES ('BRZ', 'Cruzeiro brasileiro (1942–1967)');
INSERT INTO "list" ("id", "value") VALUES ('BRE', 'Cruzeiro brasileiro (1990–1993)');
INSERT INTO "list" ("id", "value") VALUES ('BRR', 'Cruzeiro brasileiro (1993–1994)');
INSERT INTO "list" ("id", "value") VALUES ('BRB', 'Cruzeiro novo brasileiro (1967–1986)');
INSERT INTO "list" ("id", "value") VALUES ('AOK', 'Cuanza angolano (1977–1990)');
INSERT INTO "list" ("id", "value") VALUES ('AOR', 'Cuanza angolano reajustado (1995–1999)');
INSERT INTO "list" ("id", "value") VALUES ('GEK', 'Cupom Lari georgiano');
INSERT INTO "list" ("id", "value") VALUES ('MDC', 'Cupon moldávio');
INSERT INTO "list" ("id", "value") VALUES ('NIO', 'Córdoba nicaraguano');
INSERT INTO "list" ("id", "value") VALUES ('NIC', 'Córdoba nicaraguano (1988–1991)');
INSERT INTO "list" ("id", "value") VALUES ('GMD', 'Dalasi da Gâmbia');
INSERT INTO "list" ("id", "value") VALUES ('DZD', 'Dinar argelino');
INSERT INTO "list" ("id", "value") VALUES ('BHD', 'Dinar baremita');
INSERT INTO "list" ("id", "value") VALUES ('YUN', 'Dinar conversível iugoslavo (1990–1992)');
INSERT INTO "list" ("id", "value") VALUES ('HRD', 'Dinar croata');
INSERT INTO "list" ("id", "value") VALUES ('BAD', 'Dinar da Bósnia-Herzegóvina');
INSERT INTO "list" ("id", "value") VALUES ('YUD', 'Dinar forte iugoslavo (1966–1990)');
INSERT INTO "list" ("id", "value") VALUES ('YDD', 'Dinar iemenita');
INSERT INTO "list" ("id", "value") VALUES ('IQD', 'Dinar iraquiano');
INSERT INTO "list" ("id", "value") VALUES ('JOD', 'Dinar jordaniano');
INSERT INTO "list" ("id", "value") VALUES ('KWD', 'Dinar kuwaitiano');
INSERT INTO "list" ("id", "value") VALUES ('LYD', 'Dinar líbio');
INSERT INTO "list" ("id", "value") VALUES ('MKD', 'Dinar macedónio');
INSERT INTO "list" ("id", "value") VALUES ('MKN', 'Dinar macedônio (1992–1993)');
INSERT INTO "list" ("id", "value") VALUES ('YUM', 'Dinar noviy iugoslavo (1994–2002)');
INSERT INTO "list" ("id", "value") VALUES ('YUR', 'Dinar reformado iugoslavo (1992–1993)');
INSERT INTO "list" ("id", "value") VALUES ('SDD', 'Dinar sudanês (1992–2007)');
INSERT INTO "list" ("id", "value") VALUES ('RSD', 'Dinar sérvio');
INSERT INTO "list" ("id", "value") VALUES ('CSD', 'Dinar sérvio (2002–2006)');
INSERT INTO "list" ("id", "value") VALUES ('TND', 'Dinar tunisino');
INSERT INTO "list" ("id", "value") VALUES ('AED', 'Dirham dos Emirados Árabes Unidos');
INSERT INTO "list" ("id", "value") VALUES ('MAD', 'Dirham marroquino');
INSERT INTO "list" ("id", "value") VALUES ('STD', 'Dobra de São Tomé e Príncipe');
INSERT INTO "list" ("id", "value") VALUES ('VND', 'Dong vietnamita');
INSERT INTO "list" ("id", "value") VALUES ('VNN', 'Dong vietnamita (1978–1985)');
INSERT INTO "list" ("id", "value") VALUES ('GRD', 'Dracma grego');
INSERT INTO "list" ("id", "value") VALUES ('AMD', 'Dram arménio');
INSERT INTO "list" ("id", "value") VALUES ('AUD', 'Dólar australiano');
INSERT INTO "list" ("id", "value") VALUES ('BBD', 'Dólar barbadense');
INSERT INTO "list" ("id", "value") VALUES ('BZD', 'Dólar belizense');
INSERT INTO "list" ("id", "value") VALUES ('BMD', 'Dólar bermudense');
INSERT INTO "list" ("id", "value") VALUES ('BND', 'Dólar bruneíno');
INSERT INTO "list" ("id", "value") VALUES ('CAD', 'Dólar canadiano');
INSERT INTO "list" ("id", "value") VALUES ('GYD', 'Dólar da Guiana');
INSERT INTO "list" ("id", "value") VALUES ('NAD', 'Dólar da Namíbia');
INSERT INTO "list" ("id", "value") VALUES ('BSD', 'Dólar das Bahamas');
INSERT INTO "list" ("id", "value") VALUES ('XCD', 'Dólar das Caraíbas Orientais');
INSERT INTO "list" ("id", "value") VALUES ('KYD', 'Dólar das Ilhas Caimão');
INSERT INTO "list" ("id", "value") VALUES ('SBD', 'Dólar das Ilhas Salomão');
INSERT INTO "list" ("id", "value") VALUES ('FJD', 'Dólar de Fiji');
INSERT INTO "list" ("id", "value") VALUES ('HKD', 'Dólar de Hong Kong');
INSERT INTO "list" ("id", "value") VALUES ('SGD', 'Dólar de Singapura');
INSERT INTO "list" ("id", "value") VALUES ('TTD', 'Dólar de Trindade e Tobago');
INSERT INTO "list" ("id", "value") VALUES ('CNX', 'Dólar do Banco Popular da China');
INSERT INTO "list" ("id", "value") VALUES ('SRD', 'Dólar do Suriname');
INSERT INTO "list" ("id", "value") VALUES ('ZWD', 'Dólar do Zimbábue (1980–2008)');
INSERT INTO "list" ("id", "value") VALUES ('ZWR', 'Dólar do Zimbábue (2008)');
INSERT INTO "list" ("id", "value") VALUES ('ZWL', 'Dólar do Zimbábue (2009)');
INSERT INTO "list" ("id", "value") VALUES ('USD', 'Dólar dos Estados Unidos');
INSERT INTO "list" ("id", "value") VALUES ('JMD', 'Dólar jamaicano');
INSERT INTO "list" ("id", "value") VALUES ('LRD', 'Dólar liberiano');
INSERT INTO "list" ("id", "value") VALUES ('NZD', 'Dólar neozelandês');
INSERT INTO "list" ("id", "value") VALUES ('USN', 'Dólar norte-americano (Dia seguinte)');
INSERT INTO "list" ("id", "value") VALUES ('USS', 'Dólar norte-americano (Mesmo dia)');
INSERT INTO "list" ("id", "value") VALUES ('RHD', 'Dólar rodesiano');
INSERT INTO "list" ("id", "value") VALUES ('GQE', 'Ekwele da Guiné Equatorial');
INSERT INTO "list" ("id", "value") VALUES ('CVE', 'Escudo cabo-verdiano');
INSERT INTO "list" ("id", "value") VALUES ('CLE', 'Escudo chileno');
INSERT INTO "list" ("id", "value") VALUES ('GWE', 'Escudo da Guiné Portuguesa');
INSERT INTO "list" ("id", "value") VALUES ('MZE', 'Escudo de Moçambique');
INSERT INTO "list" ("id", "value") VALUES ('PTE', 'Escudo português');
INSERT INTO "list" ("id", "value") VALUES ('TPE', 'Escudo timorense');
INSERT INTO "list" ("id", "value") VALUES ('EUR', 'Euro');
INSERT INTO "list" ("id", "value") VALUES ('CHE', 'Euro WIR');
INSERT INTO "list" ("id", "value") VALUES ('ANG', 'Florim das Antilhas Holandesas');
INSERT INTO "list" ("id", "value") VALUES ('AWG', 'Florim de Aruba');
INSERT INTO "list" ("id", "value") VALUES ('SRG', 'Florim do Suriname');
INSERT INTO "list" ("id", "value") VALUES ('NLG', 'Florim holandês');
INSERT INTO "list" ("id", "value") VALUES ('HUF', 'Forint húngaro');
INSERT INTO "list" ("id", "value") VALUES ('XOF', 'Franco CFA (BCEAO)');
INSERT INTO "list" ("id", "value") VALUES ('XAF', 'Franco CFA (BEAC)');
INSERT INTO "list" ("id", "value") VALUES ('XPF', 'Franco CFP');
INSERT INTO "list" ("id", "value") VALUES ('XFU', 'Franco UIC francês');
INSERT INTO "list" ("id", "value") VALUES ('CHW', 'Franco WIR');
INSERT INTO "list" ("id", "value") VALUES ('BEF', 'Franco belga');
INSERT INTO "list" ("id", "value") VALUES ('BEC', 'Franco belga (convertível)');
INSERT INTO "list" ("id", "value") VALUES ('BEL', 'Franco belga (financeiro)');
INSERT INTO "list" ("id", "value") VALUES ('BIF', 'Franco burundiano');
INSERT INTO "list" ("id", "value") VALUES ('KMF', 'Franco comoriano');
INSERT INTO "list" ("id", "value") VALUES ('CDF', 'Franco congolês');
INSERT INTO "list" ("id", "value") VALUES ('LUC', 'Franco conversível de Luxemburgo');
INSERT INTO "list" ("id", "value") VALUES ('MGF', 'Franco de Madagascar');
INSERT INTO "list" ("id", "value") VALUES ('MLF', 'Franco de Mali');
INSERT INTO "list" ("id", "value") VALUES ('LUL', 'Franco financeiro de Luxemburgo');
INSERT INTO "list" ("id", "value") VALUES ('FRF', 'Franco francês');
INSERT INTO "list" ("id", "value") VALUES ('GNF', 'Franco guineense');
INSERT INTO "list" ("id", "value") VALUES ('DJF', 'Franco jibutiano');
INSERT INTO "list" ("id", "value") VALUES ('LUF', 'Franco luxemburguês');
INSERT INTO "list" ("id", "value") VALUES ('MAF', 'Franco marroquino');
INSERT INTO "list" ("id", "value") VALUES ('MCF', 'Franco monegasco');
INSERT INTO "list" ("id", "value") VALUES ('RWF', 'Franco ruandês');
INSERT INTO "list" ("id", "value") VALUES ('CHF', 'Franco suíço');
INSERT INTO "list" ("id", "value") VALUES ('XFO', 'Franco-ouro francês');
INSERT INTO "list" ("id", "value") VALUES ('XRE', 'Fundos RINET');
INSERT INTO "list" ("id", "value") VALUES ('HTG', 'Gourde haitiano');
INSERT INTO "list" ("id", "value") VALUES ('PYG', 'Guarani paraguaio');
INSERT INTO "list" ("id", "value") VALUES ('UAH', 'Hryvnia da Ucrânia');
INSERT INTO "list" ("id", "value") VALUES ('KRH', 'Hwan da Coreia do Sul (1953–1962)');
INSERT INTO "list" ("id", "value") VALUES ('JPY', 'Iene japonês');
INSERT INTO "list" ("id", "value") VALUES ('PEI', 'Inti peruano');
INSERT INTO "list" ("id", "value") VALUES ('UAK', 'Karbovanetz ucraniano');
INSERT INTO "list" ("id", "value") VALUES ('PGK', 'Kina da Papua-Nova Guiné');
INSERT INTO "list" ("id", "value") VALUES ('LAK', 'Kip de Laos');
INSERT INTO "list" ("id", "value") VALUES ('HRK', 'Kuna croata');
INSERT INTO "list" ("id", "value") VALUES ('MWK', 'Kwacha do Malawi');
INSERT INTO "list" ("id", "value") VALUES ('ZMW', 'Kwacha zambiano');
INSERT INTO "list" ("id", "value") VALUES ('ZMK', 'Kwacha zambiano (1968–2012)');
INSERT INTO "list" ("id", "value") VALUES ('AOA', 'Kwanza angolano');
INSERT INTO "list" ("id", "value") VALUES ('BUK', 'Kyat birmanês');
INSERT INTO "list" ("id", "value") VALUES ('MMK', 'Kyat de Mianmar');
INSERT INTO "list" ("id", "value") VALUES ('GEL', 'Lari georgiano');
INSERT INTO "list" ("id", "value") VALUES ('LVL', 'Lats da Letónia');
INSERT INTO "list" ("id", "value") VALUES ('ALK', 'Lek Albanês (1946–1965)');
INSERT INTO "list" ("id", "value") VALUES ('ALL', 'Lek albanês');
INSERT INTO "list" ("id", "value") VALUES ('HNL', 'Lempira das Honduras');
INSERT INTO "list" ("id", "value") VALUES ('SLL', 'Leone de Serra Leoa');
INSERT INTO "list" ("id", "value") VALUES ('MDL', 'Leu moldavo');
INSERT INTO "list" ("id", "value") VALUES ('RON', 'Leu romeno');
INSERT INTO "list" ("id", "value") VALUES ('ROL', 'Leu romeno (1952–2006)');
INSERT INTO "list" ("id", "value") VALUES ('BGN', 'Lev búlgaro');
INSERT INTO "list" ("id", "value") VALUES ('BGO', 'Lev búlgaro (1879–1952)');
INSERT INTO "list" ("id", "value") VALUES ('BGL', 'Lev forte búlgaro');
INSERT INTO "list" ("id", "value") VALUES ('BGM', 'Lev socialista búlgaro');
INSERT INTO "list" ("id", "value") VALUES ('FKP', 'Libra das Ilhas Falkland');
INSERT INTO "list" ("id", "value") VALUES ('CYP', 'Libra de Chipre');
INSERT INTO "list" ("id", "value") VALUES ('GIP', 'Libra de Gibraltar');
INSERT INTO "list" ("id", "value") VALUES ('SHP', 'Libra de Santa Helena');
INSERT INTO "list" ("id", "value") VALUES ('EGP', 'Libra egípcia');
INSERT INTO "list" ("id", "value") VALUES ('GBP', 'Libra esterlina britânica');
INSERT INTO "list" ("id", "value") VALUES ('IEP', 'Libra irlandesa');
INSERT INTO "list" ("id", "value") VALUES ('ILP', 'Libra israelita');
INSERT INTO "list" ("id", "value") VALUES ('LBP', 'Libra libanesa');
INSERT INTO "list" ("id", "value") VALUES ('MTP', 'Libra maltesa');
INSERT INTO "list" ("id", "value") VALUES ('SDG', 'Libra sudanesa');
INSERT INTO "list" ("id", "value") VALUES ('SDP', 'Libra sudanesa (1957–1998)');
INSERT INTO "list" ("id", "value") VALUES ('SSP', 'Libra sul-sudanesa');
INSERT INTO "list" ("id", "value") VALUES ('SYP', 'Libra síria');
INSERT INTO "list" ("id", "value") VALUES ('SZL', 'Lilangeni da Suazilândia');
INSERT INTO "list" ("id", "value") VALUES ('ITL', 'Lira italiana');
INSERT INTO "list" ("id", "value") VALUES ('MTL', 'Lira maltesa');
INSERT INTO "list" ("id", "value") VALUES ('TRY', 'Lira turca');
INSERT INTO "list" ("id", "value") VALUES ('TRL', 'Lira turca (1922–2005)');
INSERT INTO "list" ("id", "value") VALUES ('LTL', 'Litas da Lituânia');
INSERT INTO "list" ("id", "value") VALUES ('LSL', 'Loti do Lesoto');
INSERT INTO "list" ("id", "value") VALUES ('MVP', 'Maldivian Rupee (1947–1981)');
INSERT INTO "list" ("id", "value") VALUES ('AZM', 'Manat azerbaijano (1993–2006)');
INSERT INTO "list" ("id", "value") VALUES ('AZN', 'Manat do Azerbaijão');
INSERT INTO "list" ("id", "value") VALUES ('TMM', 'Manat do Turcomenistão (1993–2009)');
INSERT INTO "list" ("id", "value") VALUES ('TMT', 'Manat do Turquemenistão');
INSERT INTO "list" ("id", "value") VALUES ('FIM', 'Marca finlandesa');
INSERT INTO "list" ("id", "value") VALUES ('DEM', 'Marco alemão');
INSERT INTO "list" ("id", "value") VALUES ('BAM', 'Marco bósnio-herzegóvino conversível');
INSERT INTO "list" ("id", "value") VALUES ('MZN', 'Metical de Moçambique');
INSERT INTO "list" ("id", "value") VALUES ('MZM', 'Metical de Moçambique (1980–2006)');
INSERT INTO "list" ("id", "value") VALUES ('BOV', 'Mvdol boliviano');
INSERT INTO "list" ("id", "value") VALUES ('NGN', 'Naira nigeriana');
INSERT INTO "list" ("id", "value") VALUES ('ERN', 'Nakfa da Eritreia');
INSERT INTO "list" ("id", "value") VALUES ('BTN', 'Ngultrum do Butão');
INSERT INTO "list" ("id", "value") VALUES ('AON', 'Novo cuanza angolano (1990–2000)');
INSERT INTO "list" ("id", "value") VALUES ('BAN', 'Novo dinar da Bósnia-Herzegovina (1994–1997)');
INSERT INTO "list" ("id", "value") VALUES ('TWD', 'Novo dólar taiwanês');
INSERT INTO "list" ("id", "value") VALUES ('DDM', 'Ostmark da Alemanha Oriental');
INSERT INTO "list" ("id", "value") VALUES ('MRO', 'Ouguiya da Mauritânia');
INSERT INTO "list" ("id", "value") VALUES ('MOP', 'Pataca de Macau');
INSERT INTO "list" ("id", "value") VALUES ('TOP', 'Paʻanga de Tonga');
INSERT INTO "list" ("id", "value") VALUES ('ADP', 'Peseta de Andorra');
INSERT INTO "list" ("id", "value") VALUES ('ESP', 'Peseta espanhola');
INSERT INTO "list" ("id", "value") VALUES ('ESA', 'Peseta espanhola (conta A)');
INSERT INTO "list" ("id", "value") VALUES ('ESB', 'Peseta espanhola (conta conversível)');
INSERT INTO "list" ("id", "value") VALUES ('MXP', 'Peso Plata mexicano (1861–1992)');
INSERT INTO "list" ("id", "value") VALUES ('ARS', 'Peso argentino');
INSERT INTO "list" ("id", "value") VALUES ('ARM', 'Peso argentino (1881–1970)');
INSERT INTO "list" ("id", "value") VALUES ('ARP', 'Peso argentino (1983–1985)');
INSERT INTO "list" ("id", "value") VALUES ('BOP', 'Peso boliviano');
INSERT INTO "list" ("id", "value") VALUES ('CLP', 'Peso chileno');
INSERT INTO "list" ("id", "value") VALUES ('COP', 'Peso colombiano');
INSERT INTO "list" ("id", "value") VALUES ('CUP', 'Peso cubano');
INSERT INTO "list" ("id", "value") VALUES ('CUC', 'Peso cubano conversível');
INSERT INTO "list" ("id", "value") VALUES ('GWP', 'Peso da Guiné-Bissau');
INSERT INTO "list" ("id", "value") VALUES ('DOP', 'Peso dominicano');
INSERT INTO "list" ("id", "value") VALUES ('PHP', 'Peso filipino');
INSERT INTO "list" ("id", "value") VALUES ('ARL', 'Peso lei argentino (1970–1983)');
INSERT INTO "list" ("id", "value") VALUES ('MXN', 'Peso mexicano');
INSERT INTO "list" ("id", "value") VALUES ('UYU', 'Peso uruguaio');
INSERT INTO "list" ("id", "value") VALUES ('UYP', 'Peso uruguaio (1975–1993)');
INSERT INTO "list" ("id", "value") VALUES ('UYI', 'Peso uruguaio en unidades indexadas');
INSERT INTO "list" ("id", "value") VALUES ('BWP', 'Pula de Botswana');
INSERT INTO "list" ("id", "value") VALUES ('GTQ', 'Quetzal da Guatemala');
INSERT INTO "list" ("id", "value") VALUES ('ZAR', 'Rand sul-africano');
INSERT INTO "list" ("id", "value") VALUES ('ZAL', 'Rand sul-africano (financeiro)');
INSERT INTO "list" ("id", "value") VALUES ('BRL', 'Real brasileiro');
INSERT INTO "list" ("id", "value") VALUES ('OMR', 'Rial de Omã');
INSERT INTO "list" ("id", "value") VALUES ('QAR', 'Rial do Catar');
INSERT INTO "list" ("id", "value") VALUES ('YER', 'Rial iemenita');
INSERT INTO "list" ("id", "value") VALUES ('IRR', 'Rial iraniano');
INSERT INTO "list" ("id", "value") VALUES ('SAR', 'Rial saudita');
INSERT INTO "list" ("id", "value") VALUES ('KHR', 'Riel cambojano');
INSERT INTO "list" ("id", "value") VALUES ('MYR', 'Ringgit malaio');
INSERT INTO "list" ("id", "value") VALUES ('BYN', 'Rublo bielorrusso');
INSERT INTO "list" ("id", "value") VALUES ('BYR', 'Rublo bielorrusso (2000–2016)');
INSERT INTO "list" ("id", "value") VALUES ('TJR', 'Rublo do Tadjiquistão');
INSERT INTO "list" ("id", "value") VALUES ('LVR', 'Rublo letão');
INSERT INTO "list" ("id", "value") VALUES ('BYB', 'Rublo novo bielorusso (1994–1999)');
INSERT INTO "list" ("id", "value") VALUES ('RUB', 'Rublo russo');
INSERT INTO "list" ("id", "value") VALUES ('RUR', 'Rublo russo (1991–1998)');
INSERT INTO "list" ("id", "value") VALUES ('SUR', 'Rublo soviético');
INSERT INTO "list" ("id", "value") VALUES ('MVR', 'Rupia das Ilhas Maldivas');
INSERT INTO "list" ("id", "value") VALUES ('LKR', 'Rupia do Sri Lanka');
INSERT INTO "list" ("id", "value") VALUES ('INR', 'Rupia indiana');
INSERT INTO "list" ("id", "value") VALUES ('IDR', 'Rupia indonésia');
INSERT INTO "list" ("id", "value") VALUES ('MUR', 'Rupia mauriciana');
INSERT INTO "list" ("id", "value") VALUES ('NPR', 'Rupia nepalesa');
INSERT INTO "list" ("id", "value") VALUES ('PKR', 'Rupia paquistanesa');
INSERT INTO "list" ("id", "value") VALUES ('SCR', 'Rupia seichelense');
INSERT INTO "list" ("id", "value") VALUES ('ILR', 'Sheqel antigo israelita');
INSERT INTO "list" ("id", "value") VALUES ('ILS', 'Sheqel novo israelita');
INSERT INTO "list" ("id", "value") VALUES ('PEN', 'Sol peruano');
INSERT INTO "list" ("id", "value") VALUES ('PES', 'Sol peruano (1863–1965)');
INSERT INTO "list" ("id", "value") VALUES ('KGS', 'Som do Quirguistão');
INSERT INTO "list" ("id", "value") VALUES ('UZS', 'Som do Uzbequistão');
INSERT INTO "list" ("id", "value") VALUES ('TJS', 'Somoni do Tajaquistão');
INSERT INTO "list" ("id", "value") VALUES ('ECS', 'Sucre equatoriano');
INSERT INTO "list" ("id", "value") VALUES ('GNS', 'Syli da Guiné');
INSERT INTO "list" ("id", "value") VALUES ('BDT', 'Taka de Bangladesh');
INSERT INTO "list" ("id", "value") VALUES ('WST', 'Tala samoano');
INSERT INTO "list" ("id", "value") VALUES ('LTT', 'Talonas lituano');
INSERT INTO "list" ("id", "value") VALUES ('KZT', 'Tenge do Cazaquistão');
INSERT INTO "list" ("id", "value") VALUES ('SIT', 'Tolar Bons esloveno');
INSERT INTO "list" ("id", "value") VALUES ('MNT', 'Tugrik da Mongólia');
INSERT INTO "list" ("id", "value") VALUES ('MXV', 'Unidad de Inversion (UDI) mexicana');
INSERT INTO "list" ("id", "value") VALUES ('ECV', 'Unidad de Valor Constante (UVC) do Equador');
INSERT INTO "list" ("id", "value") VALUES ('XEU', 'Unidade de Moeda Europeia');
INSERT INTO "list" ("id", "value") VALUES ('COU', 'Unidade de Valor Real');
INSERT INTO "list" ("id", "value") VALUES ('CLF', 'Unidades de Fomento chilenas');
INSERT INTO "list" ("id", "value") VALUES ('VUV', 'Vatu de Vanuatu');
INSERT INTO "list" ("id", "value") VALUES ('KRO', 'Won da Coreia do Sul (1945–1953)');
INSERT INTO "list" ("id", "value") VALUES ('KPW', 'Won norte-coreano');
INSERT INTO "list" ("id", "value") VALUES ('KRW', 'Won sul-coreano');
INSERT INTO "list" ("id", "value") VALUES ('ATS', 'Xelim austríaco');
INSERT INTO "list" ("id", "value") VALUES ('KES', 'Xelim queniano');
INSERT INTO "list" ("id", "value") VALUES ('SOS', 'Xelim somali');
INSERT INTO "list" ("id", "value") VALUES ('TZS', 'Xelim tanzaniano');
INSERT INTO "list" ("id", "value") VALUES ('UGX', 'Xelim ugandense');
INSERT INTO "list" ("id", "value") VALUES ('UGS', 'Xelim ugandense (1966–1987)');
INSERT INTO "list" ("id", "value") VALUES ('CNY', 'Yuan chinês');
INSERT INTO "list" ("id", "value") VALUES ('ZRN', 'Zaire Novo zairense (1993–1998)');
INSERT INTO "list" ("id", "value") VALUES ('ZRZ', 'Zaire zairense (1971–1993)');
INSERT INTO "list" ("id", "value") VALUES ('PLN', 'Zloti polaco');
INSERT INTO "list" ("id", "value") VALUES ('PLZ', 'Zloti polonês (1950–1995)');


text:
<!-- Do not edit this file. It is automatically generated by API Documenter. -->

[Home](./index.md) > [@snowplow/browser-tracker](./browser-tracker.md) > [DisableAnonymousTrackingConfiguration](./browser-tracker.disableanonymoustrackingconfiguration.md) > [stateStorageStrategy](./browser-tracker.disableanonymoustrackingconfiguration.statestoragestrategy.md)

## DisableAnonymousTrackingConfiguration.stateStorageStrategy property

<b>Signature:</b>

```typescript
stateStorageStrategy?: StateStorageStrategy;
```

redpajama_set_name: RedPajamaGithub


text:
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout
  xmlns:android="http://schemas.android.com/apk/res/android"
  android:layout_width="match_parent"
  android:layout_height="wrap_content"
  android:minHeight="@dimen/height_item_multiline"
  android:background="?clickableBackground"
  android:paddingRight="@dimen/margin_base"
  android:paddingEnd="@dimen/margin_base"
  android:paddingLeft="@dimen/margin_base"
  android:paddingStart="@dimen/margin_base">

  <ImageView
    android:id="@+id/iv__bookmark_color"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:layout_alignParentLeft="true"
    android:layout_centerVertical="true"
    android:layout_alignParentStart="true"
    android:layout_marginRight="@dimen/margin_base"
    android:layout_marginEnd="@dimen/margin_base"/>

  <LinearLayout
    android:layout_width="wrap_content"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:layout_centerVertical="true"
    android:layout_toRightOf="@id/iv__bookmark_color"
    android:layout_toEndOf="@id/iv__bookmark_color"
    android:layout_toLeftOf="@id/more"
    android:layout_toStartOf="@id/more">
    <TextView
      android:id="@+id/tv__bookmark_name"
      android:layout_width="wrap_content"
      android:layout_height="wrap_content"
      android:singleLine="true"
      android:textAppearance="@style/MwmTextAppearance.Body1"/>

    <TextView
      android:id="@+id/tv__bookmark_distance"
      android:layout_width="wrap_content"
      android:layout_height="wrap_content"
      android:textAppearance="@style/MwmTextAppearance.Body3"/>
  </LinearLayout>
</RelativeLayout>


text:
import os
execfile(os.path.expanduser("~/.emscripten"))
print EMSCRIPTEN_ROOT


text:
A styleable, accessible `<select>` component.

[Link to demo](#)

## Requirements

- Sass
- AMD loader
- Dust templating

## Installation

Installation instructions. Be as brief as possible without leaving out necessary requirements.

## Usage

- How to

## Development

* run `npm install`
* run `bower install`
* run `grunt serve`
* navigate to [localhost:3000/tests/visual](http://localhost:3000/tests/visual)


text:
package cli

import (
	"flag"
	"time"

	"github.com/cloudflare/cfssl/config"
	"github.com/cloudflare/cfssl/helpers"
	"github.com/cloudflare/cfssl/log"
	"github.com/cloudflare/cfssl/signer/universal"
)

// Config is a type to hold flag values used by cfssl commands.
type Config struct {
	Hostname          string
	CertFile          string
	CSRFile           string
	CAFile            string
	CAKeyFile         string
	TLSCertFile       string
	TLSKeyFile        string
	MutualTLSCAFile   string
	MutualTLSCNRegex  string
	TLSRemoteCAs      string
	MutualTLSCertFile string
	MutualTLSKeyFile  string
	KeyFile           string
	IntermediatesFile string
	CABundleFile      string
	IntBundleFile     string
	Address           string
	Port              int
	MinTLSVersion     string
	Password          string
	ConfigFile        string
	CFG               *config.Config
	Profile           string
	IsCA              bool
	RenewCA           bool
	IntDir            string
	Flavor            string
	Metadata          string
	Domain            string
	IP                string
	Remote            string
	Label             string
	AuthKey           string
	ResponderFile     string
	ResponderKeyFile  string
	Status            string
	Reason            string
	RevokedAt         string
	Interval          time.Duration
	List              bool
	Family            string
	Timeout           time.Duration
	Scanner           string
	CSVFile           string
	NumWorkers        int
	MaxHosts          int
	Responses         string
	Path              string
	CRL               string
	Usage             string
	PGPPrivate        string
	PGPName           string
	Serial            string
	CNOverride        string
	AKI               string
	DBConfigFile      string
	CRLExpiration     time.Duration
	Disable     	  string
}

// registerFlags defines all cfssl command flags and associates their values with variables.
func registerFlags(c *Config, f *flag.FlagSet) {
	f.StringVar(&c.Hostname, "hostname", "", "Hostname for the cert, could be a comma-separated hostname list")
	f.StringVar(&c.CertFile, "cert", "", "Client certificate that contains the public key")
	f.StringVar(&c.CSRFile, "csr", "", "Certificate signature request file for new public key")
	f.StringVar(&c.CAFile, "ca", "", "CA used to sign the new certificate -- accepts '[file:]fname' or 'env:varname'")
	f.StringVar(&c.CAKeyFile, "ca-key", "", "CA private key -- accepts '[file:]fname' or 'env:varname'")
	f.StringVar(&c.TLSCertFile, "tls-cert", "", "Other endpoint CA to set up TLS protocol")
	f.StringVar(&c.TLSKeyFile, "tls-key", "", "Other endpoint CA private key")
	f.StringVar(&c.MutualTLSCAFile, "mutual-tls-ca", "", "Mutual TLS - require clients be signed by this CA ")
	f.StringVar(&c.MutualTLSCNRegex, "mutual-tls-cn", "", "Mutual TLS - regex for whitelist of allowed client CNs")
	f.StringVar(&c.TLSRemoteCAs, "tls-remote-ca", "", "CAs to trust for remote TLS requests")
	f.StringVar(&c.MutualTLSCertFile, "mutual-tls-client-cert", "", "Mutual TLS - client certificate to call remote instance requiring client certs")
	f.StringVar(&c.MutualTLSKeyFile, "mutual-tls-client-key", "", "Mutual TLS - client key to call remote instance requiring client certs")
	f.StringVar(&c.KeyFile, "key", "", "private key for the certificate")
	f.StringVar(&c.IntermediatesFile, "intermediates", "", "intermediate certs")
	f.StringVar(&c.CABundleFile, "ca-bundle", "", "path to root certificate store")
	f.StringVar(&c.IntBundleFile, "int-bundle", "", "path to intermediate certificate store")
	f.StringVar(&c.Address, "address", "127.0.0.1", "Address to bind")
	f.IntVar(&c.Port, "port", 8888, "Port to bind")
	f.StringVar(&c.MinTLSVersion, "min-tls-version", "", "Minimum version of TLS to use, defaults to 1.0")
	f.StringVar(&c.ConfigFile, "config", "", "path to configuration file")
	f.StringVar(&c.Profile, "profile", "", "signing profile to use")
	f.BoolVar(&c.IsCA, "initca", false, "initialise new CA")
	f.BoolVar(&c.RenewCA, "renewca", false, "re-generate a CA certificate from existing CA certificate/key")
	f.StringVar(&c.IntDir, "int-dir", "", "specify intermediates directory")
	f.StringVar(&c.Flavor, "flavor", "ubiquitous", "Bundle Flavor: ubiquitous, optimal and force.")
	f.StringVar(&c.Metadata, "metadata", "", "Metadata file for root certificate presence. The content of the file is a json dictionary (k,v): each key k is SHA-1 digest of a root certificate while value v is a list of key store filenames.")
	f.StringVar(&c.Domain, "domain", "", "remote server domain name")
	f.StringVar(&c.IP, "ip", "", "remote server ip")
	f.StringVar(&c.Remote, "remote", "", "remote CFSSL server")
	f.StringVar(&c.Label, "label", "", "key label to use in remote CFSSL server")
	f.StringVar(&c.AuthKey, "authkey", "", "key to authenticate requests to remote CFSSL server")
	f.StringVar(&c.ResponderFile, "responder", "", "Certificate for OCSP responder")
	f.StringVar(&c.ResponderKeyFile, "responder-key", "", "private key for OCSP responder certificate")
	f.StringVar(&c.Status, "status", "good", "Status of the certificate: good, revoked, unknown")
	f.StringVar(&c.Reason, "reason", "0", "Reason code for revocation")
	f.StringVar(&c.RevokedAt, "revoked-at", "now", "Date of revocation (YYYY-MM-DD)")
	f.DurationVar(&c.Interval, "interval", 4*helpers.OneDay, "Interval between OCSP updates (default: 96h)")
	f.BoolVar(&c.List, "list", false, "list possible scanners")
	f.StringVar(&c.Family, "family", "", "scanner family regular expression")
	f.StringVar(&c.Scanner, "scanner", "", "scanner regular expression")
	f.DurationVar(&c.Timeout, "timeout", 5*time.Minute, "duration (ns, us, ms, s, m, h) to scan each host before timing out")
	f.StringVar(&c.CSVFile, "csv", "", "file containing CSV of hosts")
	f.IntVar(&c.NumWorkers, "num-workers", 10, "number of workers to use for scan")
	f.IntVar(&c.MaxHosts, "max-hosts", 100, "maximum number of hosts to scan")
	f.StringVar(&c.Responses, "responses", "", "file to load OCSP responses from")
	f.StringVar(&c.Path, "path", "/", "Path on which the server will listen")
	f.StringVar(&c.CRL, "crl", "", "CRL URL Override")
	f.StringVar(&c.Password, "password", "0", "Password for accessing PKCS #12 data passed to bundler")
	f.StringVar(&c.Usage, "usage", "", "usage of private key")
	f.StringVar(&c.PGPPrivate, "pgp-private", "", "file to load a PGP Private key decryption")
	f.StringVar(&c.PGPName, "pgp-name", "", "PGP public key name, can be a comma-sepearted  key name list")
	f.StringVar(&c.Serial, "serial", "", "certificate serial number")
	f.StringVar(&c.CNOverride, "cn", "", "certificate common name (CN)")
	f.StringVar(&c.AKI, "aki", "", "certificate issuer (authority) key identifier")
	f.StringVar(&c.DBConfigFile, "db-config", "", "certificate db configuration file")
	f.DurationVar(&c.CRLExpiration, "expiry", 7*helpers.OneDay, "time from now after which the CRL will expire (default: one week)")
	f.IntVar(&log.Level, "loglevel", log.LevelInfo, "Log level (0 = DEBUG, 5 = FATAL)")
	f.StringVar(&c.Disable, "disable", "", "endpoints to disable")
}

// RootFromConfig returns a universal signer Root structure that can
// be used to produce a signer.
func RootFromConfig(c *Config) universal.Root {
	return universal.Root{
		Config: map[string]string{
			"cert-file": c.CAFile,
			"key-file":  c.CAKeyFile,
		},
		ForceRemote: c.Remote != "",
	}
}


text:
IMG=ealexhudson/stowage-webpack

container: Dockerfile
	docker build -t $(IMG) .

push:
	docker push $(IMG)


text:
require 'spec_helper'

describe Spree::Address do
  let(:address) { create(:address) }
  before        { Spree::Order.destroy_all }

  describe "#after_save" do
    it "recomputes tax for incomplete orders with the address" do
      order = create(:order_with_line_items, ship_address: address, line_items_count: 1)
      expect(SpreeAvatax::SalesOrder).to receive(:generate).with(order)
      address.save
    end

    it "does not recompute tax for completed orders for the address" do
      create(:completed_order_with_totals, ship_address: address)
      expect(SpreeAvatax::SalesOrder).not_to receive(:generate)
      address.save
    end

    it "does not recompute tax for incomplete orders with other addresses" do
      create(:order_with_line_items, line_items_count: 1)
      expect(SpreeAvatax::SalesOrder).not_to receive(:generate)
      address.save
    end
  end
end


text:
using System;
using System.Collections.Generic;
using System.Text;
using ZWave.Channel.Protocol;

namespace ZWave.CommandClasses
{
    public class ConfigurationReport : NodeReport
    {
        public readonly byte Parameter;
        public readonly byte Size;
        public readonly object Value;

        internal ConfigurationReport(Node node, byte[] payload) : base(node)
        {
            if (payload == null)
                throw new ArgumentNullException(nameof(payload));
            if (payload.Length < 3)
                throw new ReponseFormatException($"The response was not in the expected format. {GetType().Name}: Payload: {BitConverter.ToString(payload)}");

            Parameter = payload[0];
            Size = payload[1];

            try
            {
                switch (Size)
                {
                    case 1:
                        Value = PayloadConverter.ToInt8(payload, 2);
                        break;
                    case 2:
                        Value = PayloadConverter.ToInt16(payload, 2);
                        break;
                    case 4:
                        Value = PayloadConverter.ToInt32(payload, 2);
                        break;
                    case 8:
                        Value = PayloadConverter.ToInt64(payload, 2);
                        break;
                    default:
                        throw new NotSupportedException($"Size:{Size} is not supported");
                }
            }
            catch (Exception ex)
            {
                throw new ReponseFormatException($"The response was not in the expected format. Payload{BitConverter.ToString(payload)}", ex);
            }
        }

        public override string ToString()
        {
            return $"Parameter:{Parameter}, Value:{Value}";
        }
    }
}


text:
namespace Mindmancer.Common.Logging.LoggingExtensions
{
    public enum MmLogLevel
    {
        Verbose,
        Debug,
        Information,
        Warning,
        Error,
        Fatal,
    }
}


text:
This dataset has Air Pollution Emission data for the National and State geographic levels in the United States for the years 1970 to 2021.

The data is categorized by geographic levels as below:

        1. Criteria pollutants National Tier 1 for 1970 - 2021
        2. Criteria pollutants State Tier 1 for 1990 - 2021

### Download URL
The data in xlsx formats are downloadable from https://www.epa.gov/air-emissions-inventories/air-pollutant-emissions-trends-data.
The actual URLs are listed in download.py.

#### API Output
These are the attributes that we will use
| Attribute      				| Description                                               |
|-------------------------------|-----------------------------------------------------------|
| year       					| The Year of the emission estimates provided. 				|
| geo_ID      					| The Area of the emission estimates provided. 				|
| Source Category   	        | Source from where the pollution is emitted.               |
| Pollutant   				    | The Gas generated which pollutes the Air. 			    |

#### Cleaned Data
Cleaned data will be inside [output/airpollution_emission_trends_tier1.csv] as a CSV file with the following columns.

- year
- geo_Id
- SV
- Measurement_Method
- observation

#### MCFs and Template MCFs
- [output/airpollution_emission_trends_tier1.mcf]
- [output/airpollution_emission_trends_tier1.tmcf]

### Running Tests

Run the test cases

`run_tests.sh -p scripts/us_epa/air_emissions_inventory/national_state`

### Import Procedure

The below script will download the data.

`python3 download.py`

The below script will clean the data, Also generate final csv, mcf and tmcf files.

`python3 process.py`


text:
package org.medicmobile.service;

import org.joda.time.DateTime;
import org.medicmobile.dto.ReportSearch;
import org.medicmobile.dto.ReportUpdates;
import org.medicmobile.dto.VisitUpdate;
import org.medicmobile.dto.WeeklyReport;
import org.motechproject.event.MotechEvent;

/**
 * The Interface WeeklyReportService.
 */
public interface WeeklyReportService {

      /**
       * Gets the weekly report.
       *
       * @param reportSearch
       *              the report search
       * @return the weekly report
       */
      WeeklyReport getWeeklyReport(ReportSearch reportSearch);

      /**
       * Update.
       *
       * @param visitUpdate
       *              the visit update
       * @return true, if successful
       */
      boolean update(VisitUpdate visitUpdate);

      /**
       * Update from report.
       *
       * @param reportUpdates
       *              the report updates
       * @return true, if successful
       */
      boolean updateFromReport(ReportUpdates reportUpdates);

      /**
       * Send reminders.
       *
       * @param event
       *              the event
       */
      void sendReminders(MotechEvent event);

      void scheduleSMSToAnganwadi(String anganwadiID, DateTime date);

      void rescheduleAppointmentDailyJob();
}


text:
using System;
using System.Collections.Generic;
using System.Net.Http;
using AutoFixture;
using FluentAssertions;
using Moq;
using Newtonsoft.Json;
using Newtonsoft.Json.Serialization;
using PactNet.Interop;
using Xunit;
using Match = PactNet.Matchers.Match;

namespace PactNet.Tests
{
    public class RequestBuilderTests
    {
        private readonly RequestBuilder builder;

        private readonly Mock<IMockServer> mockServer;

        private readonly IFixture fixture;
        private readonly InteractionHandle handle;
        private readonly JsonSerializerSettings settings;

        public RequestBuilderTests()
        {
            this.mockServer = new Mock<IMockServer>();

            this.fixture = new Fixture();
            var customization = new SupportMutableValueTypesCustomization();
            customization.Customize(this.fixture);

            this.handle = this.fixture.Create<InteractionHandle>();
            this.settings = new JsonSerializerSettings();

            this.builder = new RequestBuilder(this.mockServer.Object, this.handle, this.settings);
        }

        [Fact]
        public void Given_WhenCalled_AddsProviderState()
        {
            this.builder.Given("provider state");

            this.mockServer.Verify(s => s.Given(this.handle, "provider state"));
        }

        [Fact]
        public void Given_WithParams_AddsProviderState()
        {
            this.builder.Given("provider state",
                               new Dictionary<string, string>
                               {
                                   ["foo"] = "bar",
                                   ["baz"] = "bash",
                               });

            this.mockServer.Verify(s => s.GivenWithParam(this.handle, "provider state", "foo", "bar"));
            this.mockServer.Verify(s => s.GivenWithParam(this.handle, "provider state", "baz", "bash"));
        }

        [Fact]
        public void WithRequest_HttpMethod_AddsRequest()
        {
            this.builder.WithRequest(HttpMethod.Post, "/some/path");

            this.mockServer.Verify(s => s.WithRequest(this.handle, "POST", "/some/path"));
        }

        [Fact]
        public void WithRequest_String_AddsRequest()
        {
            this.builder.WithRequest("POST", "/some/path");

            this.mockServer.Verify(s => s.WithRequest(this.handle, "POST", "/some/path"));
        }

        [Fact]
        public void WithQuery_WhenCalled_AddsQueryParam()
        {
            this.builder.WithQuery("name", "value");

            this.mockServer.Verify(s => s.WithQueryParameter(this.handle, "name", "value", 0));
        }

        [Fact]
        public void WithQuery_RepeatedQuery_SetsIndex()
        {
            this.builder.WithQuery("name", "value1");
            this.builder.WithQuery("name", "value2");
            this.builder.WithQuery("other", "value");

            this.mockServer.Verify(s => s.WithQueryParameter(this.handle, "name", "value1", 0));
            this.mockServer.Verify(s => s.WithQueryParameter(this.handle, "name", "value2", 1));
            this.mockServer.Verify(s => s.WithQueryParameter(this.handle, "other", "value", 0));
        }

        [Fact]
        public void WithHeader_Matcher_WhenCalled_AddsSerialisedHeaderParam()
        {
            var expectedValue = "{\"pact:matcher:type\":\"regex\",\"value\":\"header\",\"regex\":\"^header$\"}";

            this.builder.WithHeader("name", Match.Regex("header", "^header$"));

            this.mockServer.Verify(s => s.WithRequestHeader(this.handle, "name", expectedValue, 0));
        }

        [Fact]
        public void WithHeader_RepeatedMatcherHeader_SetsIndex()
        {
            var expectedValue1 = "{\"pact:matcher:type\":\"regex\",\"value\":\"value1\",\"regex\":\"^value1$\"}";
            var expectedValue2 = "{\"pact:matcher:type\":\"type\",\"value\":\"value2\"}";
            var expectedValue = "{\"pact:matcher:type\":\"regex\",\"value\":\"value\",\"regex\":\"^value$\"}";

            this.builder.WithHeader("name", Match.Regex("value1", "^value1$"));
            this.builder.WithHeader("name", Match.Type("value2"));
            this.builder.WithHeader("other", Match.Regex("value", "^value$"));

            this.mockServer.Verify(s => s.WithRequestHeader(this.handle, "name", expectedValue1, 0));
            this.mockServer.Verify(s => s.WithRequestHeader(this.handle, "name", expectedValue2, 1));
            this.mockServer.Verify(s => s.WithRequestHeader(this.handle, "other", expectedValue, 0));
        }

        [Fact]
        public void WithHeader_String_WhenCalled_AddsHeaderParam()
        {
            this.builder.WithHeader("name", "value");

            this.mockServer.Verify(s => s.WithRequestHeader(this.handle, "name", "value", 0));
        }

        [Fact]
        public void WithHeader_RepeatedStringHeader_SetsIndex()
        {
            this.builder.WithHeader("name", "value1");
            this.builder.WithHeader("name", "value2");
            this.builder.WithHeader("other", "value");

            this.mockServer.Verify(s => s.WithRequestHeader(this.handle, "name", "value1", 0));
            this.mockServer.Verify(s => s.WithRequestHeader(this.handle, "name", "value2", 1));
            this.mockServer.Verify(s => s.WithRequestHeader(this.handle, "other", "value", 0));
        }

        [Fact]
        public void WithJsonBody_WithoutCustomSettings_AddsRequestBodyWithDefaultSettings()
        {
            this.builder.WithJsonBody(new { Foo = 42 });

            this.mockServer.Verify(s => s.WithRequestBody(this.handle, "application/json", @"{""Foo"":42}"));
        }

        [Fact]
        public void WithJsonBody_WithCustomSettings_AddsRequestBodyWithOverriddenSettings()
        {
            this.builder.WithJsonBody(new { Foo = 42 },
                                      new JsonSerializerSettings { ContractResolver = new CamelCasePropertyNamesContractResolver() });

            this.mockServer.Verify(s => s.WithRequestBody(this.handle, "application/json", @"{""foo"":42}"));
        }

        [Fact]
        public void WillRespond_RequestConfigured_ReturnsResponseBuilder()
        {
            this.builder.WithRequest(HttpMethod.Delete, "/foo");

            var responseBuilder = this.builder.WillRespond();

            responseBuilder.Should().BeOfType<ResponseBuilder>();
        }

        [Fact]
        public void WillRespond_RequestNotConfigured_ThrowsInvalidOperationException()
        {
            Action action = () => this.builder.WillRespond();

            action.Should().Throw<InvalidOperationException>("because the request has not been configured");
        }
    }
}


text:
#include "amd_isa.h"
#include "common/common.h"
#include "core/plugins.h"
#include "official/RGA/Common/AmdDxGsaCompile.h"
#include "official/RGA/elf/elf32.h"
#include "amd_isa_devices.h"

#if ENABLED(RDOC_X64)
#define DLL_NAME "atidxx64.dll"
#else
#define DLL_NAME "atidxx32.dll"
#endif

static const char *driverDllErrorMessage = R"(Error loading atidxx64.dll.

Currently atidxx64.dll from AMD's driver package is required for GCN disassembly and it cannot be
distributed with RenderDoc.

To see instructions on how to download and configure it on your system, go to:
https://github.com/baldurk/renderdoc/wiki/GCN-ISA)";

namespace GCNISA
{
extern std::string pluginPath;

static HMODULE GetAMDModule()
{
  // first try in the plugin locations
  HMODULE module = LoadLibraryA(LocatePluginFile(GCNISA::pluginPath, DLL_NAME).c_str());

  // if that failed then try checking for it just in the default search path
  if(module == NULL)
    module = LoadLibraryA(DLL_NAME);

  return module;
}

std::string DisassembleDXBC(const bytebuf &shaderBytes, const std::string &target)
{
  HMODULE mod = GetAMDModule();

  if(mod == NULL)
    return "; Error loading " DLL_NAME R"(.

; Currently atidxx64.dll from AMD's driver package is required for GCN disassembly and it cannot be
; distributed with RenderDoc.

; To see instructions on how to download and configure it on your system, go to:
; https://github.com/baldurk/renderdoc/wiki/GCN-ISA)";

  // if shaderBytes is empty we're testing support, so return empty string - indicating no error
  // initialising
  if(shaderBytes.empty() || target == "")
    return "";

  PfnAmdDxGsaCompileShader compileShader =
      (PfnAmdDxGsaCompileShader)GetProcAddress(mod, "AmdDxGsaCompileShader");
  PfnAmdDxGsaFreeCompiledShader freeShader =
      (PfnAmdDxGsaFreeCompiledShader)GetProcAddress(mod, "AmdDxGsaFreeCompiledShader");

  AmdDxGsaCompileShaderInput in = {};
  AmdDxGsaCompileShaderOutput out = {};

  AmdDxGsaCompileOption opts[1] = {};

  in.inputType = GsaInputDxAsmBin;
  in.numCompileOptions = 0;
  in.pCompileOptions = opts;

  for(int i = 0; i < asicCount; i++)
  {
    const asic &a = asicInfo[i];
    if(target == a.name)
    {
      in.chipFamily = a.chipFamily;
      in.chipRevision = a.chipRevision;
      break;
    }
  }

  bool amdil = false;
  if(target == "AMDIL")
  {
    in.chipFamily = asicInfo[0].chipFamily;
    in.chipRevision = asicInfo[0].chipRevision;
    amdil = true;
  }

  if(in.chipFamily == 0)
    return "; Invalid ISA Target specified";

  // we do a little mini parse of the DXBC file, just enough to get the shader code out. This is
  // because we're getting called from outside the D3D backend where the shader bytes are opaque.

  const char *dxbcParseError = "; Failed to fetch D3D shader code from DXBC";

  const byte *base = shaderBytes.data();
  const uint32_t *end = (const uint32_t *)(base + shaderBytes.size());
  const uint32_t *dxbc = (const uint32_t *)base;

  if(*dxbc != MAKE_FOURCC('D', 'X', 'B', 'C'))
    return dxbcParseError;

  dxbc++;       // fourcc
  dxbc += 4;    // hash
  dxbc++;       // unknown
  dxbc++;       // fileLength

  if(dxbc >= end)
    return dxbcParseError;

  const uint32_t numChunks = *dxbc;
  dxbc++;

  std::vector<uint32_t> chunkOffsets;
  for(uint32_t i = 0; i < numChunks; i++)
  {
    if(dxbc >= end)
      return dxbcParseError;

    chunkOffsets.push_back(*dxbc);
    dxbc++;
  }

  in.pShaderByteCode = NULL;
  in.byteCodeLength = 0;

  for(uint32_t offs : chunkOffsets)
  {
    dxbc = (const uint32_t *)(base + offs);

    if(dxbc + 2 >= end)
      return dxbcParseError;

    if(*dxbc == MAKE_FOURCC('S', 'H', 'E', 'X') || *dxbc == MAKE_FOURCC('S', 'H', 'D', 'R'))
    {
      dxbc++;
      in.byteCodeLength = *dxbc;
      dxbc++;
      in.pShaderByteCode = dxbc;

      if(dxbc + (in.byteCodeLength / 4) > end)
        return dxbcParseError;

      break;
    }
  }

  if(in.byteCodeLength == 0)
    return dxbcParseError;

  out.size = sizeof(out);

  compileShader(&in, &out);

  if(out.pShaderBinary == NULL || out.shaderBinarySize < 16)
    return "; Failed to disassemble shader";

  const uint8_t *elf = (const uint8_t *)out.pShaderBinary;

  const Elf32_Ehdr *elfHeader = (const Elf32_Ehdr *)elf;

  std::string ret;

  // minimal code to extract data from ELF. We assume the ELF we got back is well-formed.
  if(IS_ELF(*elfHeader) && elfHeader->e_ident[EI_CLASS] == ELFCLASS32)
  {
    const Elf32_Shdr *strtab =
        (const Elf32_Shdr *)(elf + elfHeader->e_shoff + sizeof(Elf32_Shdr) * elfHeader->e_shstrndx);

    const uint8_t *strtabData = elf + strtab->sh_offset;

    const AmdDxGsaCompileStats *stats = NULL;

    for(int section = 1; section < elfHeader->e_shnum; section++)
    {
      if(section == elfHeader->e_shstrndx)
        continue;

      const Elf32_Shdr *sectHeader =
          (const Elf32_Shdr *)(elf + elfHeader->e_shoff + sizeof(Elf32_Shdr) * section);

      const char *name = (const char *)(strtabData + sectHeader->sh_name);

      const uint8_t *data = elf + sectHeader->sh_offset;

      if(!strcmp(name, ".stats"))
      {
        stats = (const AmdDxGsaCompileStats *)data;
      }
      else if(amdil && !strcmp(name, ".amdil_disassembly"))
      {
        ret.insert(0, (const char *)data, (size_t)sectHeader->sh_size);
        while(ret.back() == '\0')
          ret.pop_back();
      }
      else if(!amdil && !strcmp(name, ".disassembly"))
      {
        ret.insert(0, (const char *)data, (size_t)sectHeader->sh_size);
        while(ret.back() == '\0')
          ret.pop_back();
      }
    }

    if(stats && !amdil)
    {
      std::string statStr = StringFormat::Fmt(
          R"(; -------- Statistics ---------------------
; SGPRs: %u out of %u used
; VGPRs: %u out of %u used
; LDS: %u out of %u bytes used
; %u bytes scratch space used
; Instructions: %u ALU, %u Control Flow, %u TFETCH

)",
          stats->numSgprsUsed, stats->availableSgprs, stats->numVgprsUsed, stats->availableVgprs,
          stats->usedLdsBytes, stats->availableLdsBytes, stats->usedScratchBytes, stats->numAluInst,
          stats->numControlFlowInst, stats->numTfetchInst);

      ret.insert(ret.begin(), statStr.begin(), statStr.end());
    }

    std::string header = StringFormat::Fmt("; Disassembly for %s\n\n", target.c_str());

    ret.insert(ret.begin(), header.begin(), header.end());
  }
  else
  {
    ret = "; Invalid ELF file generated";
  }

  freeShader(out.pShaderBinary);

  return ret;
}
};


text:
DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
cd $DIR/..

# Analyze
cat build/reports/client.json | jq '.chunks[] .modules[] | select(.name | contains($SEARCH)) as $mod | .reasons[] | select(.moduleName | contains($SEARCH) | not) | .moduleName + "," + $mod.name' --arg SEARCH $1 | \
    (echo "Source file,Included file" && cat) | sed -e 's/^"//' -e 's/"$//' | column -t -s","


text:
/******************************************************************************
 * 版权所有 刘大磊 2013-07-01												  *
 *	作者:刘大磊								                                              *
 * 电话:13336390671                                                                *
 * email:ldlqdsd@126.com						                              *
 *****************************************************************************/
package com.delmar.base.web.action;

import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.struts2.ServletActionContext;
import org.springframework.beans.factory.annotation.Autowired;

import com.delmar.base.model.Carrier;
import com.delmar.base.model.CarrierTrl;
import com.delmar.base.service.CarrierService;
import com.delmar.base.service.CarrierTrlService;
import com.delmar.common.model.DelmarFile;
import com.delmar.common.model.FileRelation;
import com.delmar.common.model.FileSetting;
import com.delmar.common.service.FileRelationService;
import com.delmar.common.service.FileSettingService;
import com.delmar.core.model.Language;
import com.delmar.core.service.LanguageService;
import com.delmar.core.web.action.CoreEditPrivAction;
import com.delmar.core.web.action.PrivilegeOperator;
import com.delmar.core.web.util.FacesUtils;
import com.delmar.sys.model.Module;
import com.delmar.utils.ResourceMessage;

/**
 * @author 刘大磊 2015-02-05 16:28:29
 */
public class CarrierAction extends CoreEditPrivAction {
	private Carrier  carrier;
	private List<CarrierTrl> carrierTrlList=null;
	private List<FileRelation> fileRelationList=new ArrayList<>();
	@Autowired
	private FileSettingService fileSettingService;
	@Autowired
	private FileRelationService fileRelationService;
	@Autowired
	private CarrierService carrierService;
	@Autowired
	private CarrierTrlService carrierTrlService;
	@Autowired
	private LanguageService languageService;

	public String getPurpose()
	{
		return  ResourceMessage.getMessageWithDefault("public.javaaction."+this.getClass().getName(), "Carrier维护");
	}

	private void init()
	{

		Module module=PrivilegeOperator.getModule();
		FacesUtils.setValueInHashtableOfSession("module", module);
		Map<String,Object> param1=new HashMap<>();
		param1.put("moduleId", module.getId());
		FileSetting fs=fileSettingService.getByExample(param1);
		FacesUtils.setValueInHashtableOfSession("fileSetting", fs);

		if(carrier.getId()!=null)
		{
			Map<String,Object>  param=new HashMap();
			param.put("carrierId", carrier.getId());
			carrierTrlList=	carrierTrlService.selectByExample(param);

			List<Language> list=languageService.selectByExample(null);
			List<Language> noList=new ArrayList<>();
			if(carrierTrlList==null||carrierTrlList.size()==0)
			{
				carrierTrlList=new ArrayList<>();
				noList=list;
			}
			else
			{

				for(Language lang:list)
				{
					boolean has=false;
					for(CarrierTrl trl:carrierTrlList)
					{
						if(trl.getLanguage().equals(lang.getCode()))
						{
							has=true;
							break;
						}
					}
					if(!has)
					{
						noList.add(lang);
					}
				}
			}
			for(Language lang:noList)
			{
				CarrierTrl trl=new CarrierTrl();
				trl.setLanguage(lang.getCode());
				trl.setCarrierId(carrier.getId());
				carrierTrlList.add(trl);
			}
			 param=new HashMap<>();
			 param.put("tableName", "base_carrier");
			 param.put("tableId", carrier.getId());
			fileRelationList=this.fileRelationService.selectByExample(param);
		}
	}

	/* (non-Javadoc)
	 * @see com.delmar.core.web.action.CoreEditPrivAction#getModuleName()
	 */
	@Override
	public String getModuleName() {
		return "carrier";
	}

	/* (non-Javadoc)
	 * @see com.delmar.core.web.action.CoreEditPrivAction#delete()
	 */
	@Override
	public String delete() {
		carrierService.deleteByPrimaryKey(carrier.getId());
		return "list";
	}

	/* (non-Javadoc)
	 * @see com.delmar.core.web.action.CoreEditPrivAction#deleteList(java.lang.Integer[])
	 */
	@Override
	public void deleteList(Integer[] ids) {

		carrierService.deleteCarrierList(ids);

	}

	/* (non-Javadoc)
	 * @see com.delmar.core.web.action.CoreEditPrivAction#getModelId()
	 */
	@Override
	public Integer getModelId() {

		return carrier.getId();
	}

	/* (non-Javadoc)
	 * @see com.delmar.core.web.action.CoreEditPrivAction#editForm()
	 */
	@Override
	public void editForm() {
		 carrier= carrierService.selectByPrimaryKey(id);
		 init();
	}

	/* (non-Javadoc)
	 * @see com.delmar.core.web.action.CoreEditPrivAction#search()
	 */
	@Override
	public List search() {
		Map<String,Object> param=new HashMap<String,Object>();
		param.put("searchString",getSearchWhere());
		return carrierService.selectByExample(param);
	}

	/* (non-Javadoc)
	 * @see com.delmar.core.web.action.CoreEditPrivAction#createForm()
	 */
	@Override
	public void createForm() {
		carrier=new Carrier();
		carrierTrlList=null;
	}

	/* (non-Javadoc)
	 * @see com.delmar.core.web.action.CoreEditPrivAction#saveForm()
	 */
	@Override
	public String saveForm() {
		Date now=new Date();
		for(FileRelation fr:fileRelationList)
		{
			fr.setCreated(now);
			fr.setTableName("base_carrier");

		}
		carrierService.saveCarrier(carrier,this.carrierTrlList,fileRelationList);
		return "edit";
	}
	/**
	 * @return the usergroup
	 */
	public Carrier getCarrier() {
		return carrier;
	}

	/**
	 * @param carrier the usergroup to set
	 */
	public void setCarrier(Carrier carrier) {
		this.carrier = carrier;
	}

	/**
	 * @return the carrierTrlList
	 */
	public List<CarrierTrl> getCarrierTrlList() {
		return carrierTrlList;
	}

	/**
	 * @param carrierTrlList the carrierTrlList to set
	 */
	public void setCarrierTrlList(List<CarrierTrl> carrierTrlList) {
		this.carrierTrlList = carrierTrlList;
	}

	/**
	 * @return the fileRelationList
	 */
	public List<FileRelation> getFileRelationList() {
		return fileRelationList;
	}

	/**
	 * @param fileRelationList the fileRelationList to set
	 */
	public void setFileRelationList(List<FileRelation> fileRelationList) {
		this.fileRelationList = fileRelationList;
	}
	public String addFile()
	{
		FileRelation fr=new FileRelation();
		DelmarFile df=new DelmarFile();
		fr.setDelmarFile(df);
		fileRelationList.add(fr);
		return "edit";
	}
	public String deleteFiles()
	{
		String[] ids=ServletActionContext.getRequest().getParameterValues("ids");
		List<String> idList=new ArrayList<>();

		//
		Integer[] intids=new Integer[ids.length];

		for(int i=0;i<ids.length;i++)
		{
			idList.add(ids[i]);
			Integer index=Integer.parseInt(ids[i]);
			FileRelation column=fileRelationList.get(index);
			if(column.getId()!=null&&column.getId()!=0)
			{
				intids[i]=column.getId();
				this.fileRelationService.deleteFileRelation(column);
			}
		}
		java.util.Collections.sort(idList);
		System.out.println("columns.size="+fileRelationList.size());
		for(int i=idList.size()-1;i>=0;i--)
		{

			this.fileRelationList.remove(Integer.parseInt(idList.get(i)));
		}
		System.out.println("columns.size="+fileRelationList.size());
		return "edit";
	}
}


text:
@implementation UIColor (Hex)

//+ (UIColor *)colorWithHexString:(NSString *)color alpha:(CGFloat)alpha
//{
//    //删除字符串中的空格
//    NSString *cString = [[color stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceAndNewlineCharacterSet]] uppercaseString];
//    // String should be 6 or 8 characters
//    if ([cString length] < 6)
//    {
//        return [UIColor clearColor];
//    }
//    // strip 0X if it appears
//    //如果是0x开头的,那么截取字符串,字符串从索引为2的位置开始,一直到末尾
//    if ([cString hasPrefix:@"0X"])
//    {
//        cString = [cString substringFromIndex:2];
//    }
//    //如果是#开头的,那么截取字符串,字符串从索引为1的位置开始,一直到末尾
//    if ([cString hasPrefix:@"#"])
//    {
//        cString = [cString substringFromIndex:1];
//    }
//    if ([cString length] != 6)
//    {
//        return [UIColor clearColor];
//    }
//
//    // Separate into r, g, b substrings
//    NSRange range;
//    range.location = 0;
//    range.length = 2;
//    //r
//    NSString *rString = [cString substringWithRange:range];
//    //g
//    range.location = 2;
//    NSString *gString = [cString substringWithRange:range];
//    //b
//    range.location = 4;
//    NSString *bString = [cString substringWithRange:range];
//
//    // Scan values
//    unsigned int r, g, b;
//    [[NSScanner scannerWithString:rString] scanHexInt:&r];
//    [[NSScanner scannerWithString:gString] scanHexInt:&g];
//    [[NSScanner scannerWithString:bString] scanHexInt:&b];
//    return [UIColor colorWithRed:((float)r / 255.0f) green:((float)g / 255.0f) blue:((float)b / 255.0f) alpha:alpha];
//}

+ (instancetype)colorWithHexString:(NSString *)hexString alpha:(CGFloat)alpha{

    hexString = [[hexString stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceAndNewlineCharacterSet]] uppercaseString];

    UIColor *defaultColor = [UIColor clearColor];

    if (hexString.length < 6) return defaultColor;
    if ([hexString hasPrefix:@"#"]) hexString = [hexString substringFromIndex:1];
    if ([hexString hasPrefix:@"0x"]) hexString = [hexString substringFromIndex:2];
    if (hexString.length != 6) return defaultColor;

    //method1
    NSScanner *scanner = [NSScanner scannerWithString:hexString];
    unsigned int hexNumber;
    if (![scanner scanHexInt:&hexNumber]) return defaultColor;

    //method2
    const char *char_str = [hexString cStringUsingEncoding:NSASCIIStringEncoding];
    int hexNum;
    sscanf(char_str, "%x", &hexNum);

    return [UIColor colorWithHex:hexNumber alpha:alpha];
}

+ (instancetype)colorWithHex:(int)hexNumber alpha:(CGFloat)alpha{

    if (hexNumber > 0xFFFFFF) return nil;

    CGFloat red   = ((hexNumber >> 16) & 0xFF) / 255.0;
    CGFloat green = ((hexNumber >> 8) & 0xFF) / 255.0;
    CGFloat blue  = (hexNumber & 0xFF) / 255.0;

    UIColor *color = [UIColor colorWithRed:red green:green blue:blue alpha:alpha];

    return color;

}

//默认alpha值为1
+ (UIColor *)colorWithHexString:(NSString *)color{
    return [self colorWithHexString:color alpha:1.0f];
}

@end


text:
require "knockout-data-rails/version"

module KnockoutData
  module Rails
    class Engine < ::Rails::Engine
    end
  end
end


text:
package es.uvigo.ei.sing.biomsef
package service

import scala.concurrent.Future
import scala.xml.{ Elem => XMLElement, Node => XMLNode }

import play.api.libs.concurrent.Execution.Implicits.defaultContext

import dispatch.{ url, Http, Res }

import entity._
import util.Page

// TODO: parse List[Author] for each Article
final class EUtilsService {

  implicit val asXML: Res => XMLElement = dispatch.as.xml.Elem

  def searchArticlePMID(query: String, days: Option[Int] = None, page: Int = 0, pageSize: Int = 30): Future[Page[Article.PMID]] = {
    val offset = page * pageSize
    search("pubmed", query, days, offset, pageSize) map {
      result => Page(idList(result), page, offset, count(result))
    }
  }

  def fetchPubMedArticles(pmids: Set[Article.PMID]): Future[Set[(Article, List[Author])]] =
    fetch("pubmed", pmids, "abstract").map(parseResultArticles).map(_.toSet)

  def fetchTaxonomyScientificName(taxonomyId: Long): Future[Option[String]] =
    summary("taxonomy", taxonomyId).map(parseScientificName)

  def serviceURL(service: String): String =
    s"http://eutils.ncbi.nlm.nih.gov/entrez/eutils/$service.fcgi"

  def search(db: String, query: String, reldate: Option[Int], retstart: Int, retmax: Int): Future[XMLElement] =
    simpleHttpRequest(serviceURL("esearch"))(
      "db"       -> db,
      "term"     -> query,
      "retstart" -> retstart.toString,
      "retmax"   -> retmax.toString,
      "datetype" -> "edat",
      "reldate"  -> reldate.map(_.toString).getOrElse("")
    )

  def fetch(db: String, ids: Set[Long], rettype: String): Future[XMLElement] =
    simpleHttpRequest(serviceURL("efetch"))(
      "db"      -> db,
      "id"      -> ids.mkString(","),
      "rettype" -> rettype
    )

  def summary(db: String, id: Long): Future[XMLElement] =
    simpleHttpRequest(serviceURL("esummary"))(
      "db" -> db, "id" -> id.toString
    )

  private def simpleHttpRequest[A](address: String)(params: (String, String)*)(implicit asA: Res => A): Future[A] =
    Http(dispatch.url(address).setBodyEncoding("UTF-8") <<? params > asA)

  private def count(result: XMLElement): Int =
    (result \ "Count").headOption.fold(0)(_.text.toInt)

  private def idList(result: XMLElement): Seq[Article.PMID] =
    (result \ "IdList" \ "Id").map(_.text).map(_.toLong)

  private def parseResultArticles(result: XMLElement): Seq[(Article, List[Author])] =
    (result \ "PubmedArticle").map(parseArticle).flatten

  private def parseArticle(article: XMLNode): Option[(Article, List[Author])] =
    for {
      pmid  <- (article \\ "PMID").headOption.map(_.text.toLong)
      title <- (article \\ "ArticleTitle").headOption.map(_.text.dropRight(1))
      abstr <- (article \\ "AbstractText").headOption.map(_.text)
      year  <- (article \\ "PubDate" \\ "Year").headOption.map(_.text.toLong).orElse(Option(1900L))
      auths <- Option(parseAuthors(article)).orElse(Option(List.empty))
    } yield (Article(Some(pmid), title, title + "." + System.lineSeparator + abstr, year), auths)

  private def parseAuthors(article: XMLNode): List[Author] =
    ((article \\ "Author") map { auth ⇒
      for {
        last <- (auth \\ "LastName").headOption.map(_.text)
        frst <- (auth \\ "ForeName").headOption.map(_.text)
        init <- (auth \\ "Initials").headOption.map(_.text)
      } yield Author(last, frst, init)
    }).toList.flatten

  private def parseScientificName(result: XMLElement): Option[String] =
    (result \\ "Item").filter(_.attribute("Name").exists(_.text == "ScientificName")).headOption.map(_.text)

}


text:
namespace Bridge.Pixi.Extras
{
	[External]
	[ObjectLiteral]
	public class Font
	{
		/// <summary>
		/// The bitmap font id.
		/// </summary>
		[FieldProperty]
		public string Name { get; set; }

		/// <summary>
		/// The size of the font in pixels, e.g. 24.
		/// </summary>
		[FieldProperty]
		public int Size { get; set; }
	}
}


text:
package gobblin.metrics.metric.filter;

import com.codahale.metrics.Metric;
import com.codahale.metrics.MetricFilter;

/**
 * A utility class for working with {@link MetricFilter}s.
 *
 * @see MetricFilter
 */
public class MetricFilters {

  public static MetricFilter and(final MetricFilter metricFilter1, final MetricFilter metricFilter2) {
    return new MetricFilter() {
      @Override public boolean matches(String name, Metric metric) {
        return metricFilter1.matches(name, metric) && metricFilter2.matches(name, metric);
      }
    };
  }
}


text:
package org.apache.tapestry5.integration.app1.pages;

import org.apache.tapestry5.annotations.Property;
import org.apache.tapestry5.annotations.SessionState;
import org.apache.tapestry5.integration.app1.data.CalendarHolder;

public class ShowCalendarHolder
{
    @SessionState
    @Property
    private CalendarHolder holder;

    void onActionFromClear()
    {
        holder = null;
    }

}


text:
"""Routines for statistical evaluation of connectivity."""

from __future__ import division

import numpy as np

from .datatools import randomize_phase, atleast_3d
from .connectivity import connectivity
from .utils import cartesian, check_random_state
from .parallel import parallel_loop

def surrogate_connectivity(measure_names, data, var, nfft=512, repeats=100,
                           n_jobs=1, verbose=0, random_state=None):
    """Calculate surrogate connectivity for a multivariate time series by phase
    randomization [1]_.

    .. note:: Parameter `var` will be modified by the function. Treat as
    undefined after the function returns.

    Parameters
    ----------
    measures : str or list of str
        Name(s) of the connectivity measure(s) to calculate. See
        :class:`Connectivity` for supported measures.
    data : array, shape (trials, channels, samples) or (channels, samples)
        Time series data (2D or 3D for multiple trials)
    var : VARBase-like object
        Instance of a VAR model.
    nfft : int, optional
        Number of frequency bins to calculate. Note that these points cover the
        range between 0 and half the sampling rate.
    repeats : int, optional
        Number of surrogate samples to take.
    n_jobs : int | None, optional
        Number of jobs to run in parallel. If set to None, joblib is not used
        at all. See `joblib.Parallel` for details.
    verbose : int, optional
        Verbosity level passed to joblib.

    Returns
    -------
    result : array, shape (`repeats`, n_channels, n_channels, nfft)
        Values of the connectivity measure for each surrogate. If
        `measure_names` is a list of strings a dictionary is returned, where
        each key is the name of the measure, and the corresponding values are
        arrays of shape (`repeats`, n_channels, n_channels, nfft).

    .. [1] J. Theiler et al. Testing for nonlinearity in time series: the
           method of surrogate data. Physica D, 58: 77-94, 1992.
    """
    par, func = parallel_loop(_calc_surrogate, n_jobs=n_jobs, verbose=verbose)
    output = par(func(randomize_phase(data, random_state=random_state), var,
                      measure_names, nfft) for _ in range(repeats))
    return convert_output_(output, measure_names)

def _calc_surrogate(data, var, measure_names, nfft):
    var.fit(data)
    return connectivity(measure_names, var.coef, var.rescov, nfft)

def jackknife_connectivity(measures, data, var, nfft=512, leaveout=1, n_jobs=1,
                           verbose=0):
    """Calculate jackknife estimates of connectivity.

    For each jackknife estimate a block of trials is left out. This is repeated
    until each trial was left out exactly once. The number of estimates depends
    on the number of trials and the value of `leaveout`. It is calculated by
    repeats = `n_trials` // `leaveout`.

    .. note:: Parameter `var` will be modified by the function. Treat as
    undefined after the function returns.

    Parameters
    ----------
    measures : str or list of str
        Name(s) of the connectivity measure(s) to calculate. See
        :class:`Connectivity` for supported measures.
    data : array, shape (trials, channels, samples)
        Time series data (multiple trials).
    var : VARBase-like object
        Instance of a VAR model.
    nfft : int, optional
        Number of frequency bins to calculate. Note that these points cover the
        range between 0 and half the sampling rate.
    leaveout : int, optional
        Number of trials to leave out in each estimate.
    n_jobs : int | None, optional
        Number of jobs to run in parallel. If set to None, joblib is not used
        at all. See `joblib.Parallel` for details.
    verbose : int, optional
        Verbosity level passed to joblib.

    Returns
    -------
    result : array, shape (`repeats`, n_channels, n_channels, nfft)
        Values of the connectivity measure for each surrogate. If
        `measure_names` is a list of strings a dictionary is returned, where
        each key is the name of the measure, and the corresponding values are
        arrays of shape (`repeats`, n_channels, n_channels, nfft).
    """
    data = atleast_3d(data)
    t, m, n = data.shape

    assert(t > 1)

    if leaveout < 1:
        leaveout = int(leaveout * t)

    num_blocks = t // leaveout

    mask = lambda block: [i for i in range(t) if i < block*leaveout or
                                                 i >= (block + 1) * leaveout]

    par, func = parallel_loop(_calc_jackknife, n_jobs=n_jobs, verbose=verbose)
    output = par(func(data[mask(b), :, :], var, measures, nfft)
                 for b in range(num_blocks))
    return convert_output_(output, measures)

def _calc_jackknife(data_used, var, measure_names, nfft):
    var.fit(data_used)
    return connectivity(measure_names, var.coef, var.rescov, nfft)

def bootstrap_connectivity(measures, data, var, nfft=512, repeats=100,
                           num_samples=None, n_jobs=1, verbose=0,
                           random_state=None):
    """Calculate bootstrap estimates of connectivity.

    To obtain a bootstrap estimate trials are sampled randomly with replacement
    from the data set.

    .. note:: Parameter `var` will be modified by the function. Treat as
    undefined after the function returns.

    Parameters
    ----------
    measures : str or list of str
        Name(s) of the connectivity measure(s) to calculate. See
        :class:`Connectivity` for supported measures.
    data : array, shape (trials, channels, samples)
        Time series data (multiple trials).
    var : VARBase-like object
        Instance of a VAR model.
    nfft : int, optional
        Number of frequency bins to calculate. Note that these points cover the
        range between 0 and half the sampling rate.
    repeats : int, optional
        Number of bootstrap estimates to take.
    num_samples : int, optional
        Number of samples to take for each bootstrap estimates. Defaults to the
        same number of trials as present in the data.
    n_jobs : int, optional
        n_jobs : int | None, optional
        Number of jobs to run in parallel. If set to None, joblib is not used
        at all. See `joblib.Parallel` for details.
    verbose : int, optional
        Verbosity level passed to joblib.

    Returns
    -------
    measure : array, shape (`repeats`, n_channels, n_channels, nfft)
        Values of the connectivity measure for each bootstrap estimate. If
        `measure_names` is a list of strings a dictionary is returned, where
        each key is the name of the measure, and the corresponding values are
        arrays of shape (`repeats`, n_channels, n_channels, nfft).
    """
    rng = check_random_state(random_state)
    data = atleast_3d(data)
    n, m, t = data.shape

    assert(t > 1)

    if num_samples is None:
        num_samples = t

    mask = lambda r: rng.random_integers(0, data.shape[0]-1, num_samples)

    par, func = parallel_loop(_calc_bootstrap, n_jobs=n_jobs, verbose=verbose)
    output = par(func(data[mask(r), :, :], var, measures, nfft)
                 for r in range(repeats))
    return convert_output_(output, measures)

def _calc_bootstrap(data, var, measures, nfft):
    var.fit(data)
    return connectivity(measures, var.coef, var.rescov, nfft)

def test_bootstrap_difference(a, b):
    """Test mean difference between two bootstrap estimates.

    This function calculates the probability p of observing a more extreme mean
    difference between `a` and `b` under the null hypothesis that `a` and `b`
    come from the same distribution.

    If p is smaller than e.g. 0.05, we can reject the null hypothesis at an
    alpha-level of 0.05 and conclude that `a` and `b` likely come from
    different distributions.

    .. note:: p-values are calculated along the first dimension. Thus,
              channels * channels * nfft individual p-values are obtained. To
              determine if a difference is significant, it is important to
              correct for multiple testing.

    Parameters
    ----------
    a, b : array, shape (`repeats`, channels, channels, nfft)
        Two bootstrap estimates to compare. The number of repetitions (first
        dimension) does not have to be equal.

    Returns
    -------
    p : array, shape (channels, channels, nfft)
        p-values.

    Notes
    -----
    The function estimates the distribution of `b[j]` - `a[i]` by calculating
    the difference for each combination of `i` and `j`. The total number of
    difference samples available is therefore a.shape[0] * b.shape[0]. The
    p-value is calculated as the smallest percentile of that distribution that
    does not contain 0.

    See also
    --------
    :func:`significance_fdr` : Correct for multiple testing by controlling the
    false discovery rate.
    """
    old_shape = a.shape[1:]
    a = np.asarray(a).reshape((a.shape[0], -1))
    b = np.asarray(b).reshape((b.shape[0], -1))

    n = a.shape[0]

    s1, s2 = 0, 0
    for i in cartesian((np.arange(n), np.arange(n))):
        c = b[i[1], :] - a[i[0], :]
        s1 += c >= 0
        s2 += c <= 0

    p = np.minimum(s1, s2) / (n*n)
    return p.reshape(old_shape)

def significance_fdr(p, alpha):
    """Calculate significance by controlling for the false discovery rate.

    This function determines which of the p-values in `p` can be considered
    significant. Correction for multiple comparisons is performed by
    controlling the false discovery rate (FDR). The FDR is the maximum fraction
    of p-values that are wrongly considered significant [1]_.

    Parameters
    ----------
    p : array, shape (channels, channels, nfft)
        p-values.
    alpha : float
        Maximum false discovery rate.

    Returns
    -------
    s : array, dtype=bool, shape (channels, channels, nfft)
        Significance of each p-value.

    References
    ----------
    .. [1] Y. Benjamini, Y. Hochberg. Controlling the false discovery rate: a
           practical and powerful approach to multiple testing. J. Royal Stat.
           Soc. Series B 57(1): 289-300, 1995.
    """
    i = np.argsort(p, axis=None)
    m = i.size - np.sum(np.isnan(p))

    j = np.empty(p.shape, int)
    j.flat[i] = np.arange(1, i.size + 1)

    mask = p <= alpha * j / m

    if np.sum(mask) == 0:
        return mask

    # find largest k so that p_k <= alpha*k/m
    k = np.max(j[mask])

    # reject all H_i for i = 0...k
    s = j <= k

    return s

def convert_output_(output, measures):
    if isinstance(measures, str):
        return np.array(output)
    else:
        repeats = len(output)
        output = dict((m, np.array([output[r][m] for r in range(repeats)]))
                      for m in measures)
        return output


text:
//@ts-check
const cheerio = require("cheerio");
const axios = require("axios").default;
const { getPagination } = require("../helpers");

/**
 * @param {number} _ - index
 * @param {CheerioElement} el - cheerio .bdrank element
 */
const parseRow = (_, el) => {
    const row = cheerio(el);

    const a = row.find("div.search_title > a");
    const id = row.find("div.search_title > span").attr("id").replace("sid", "");
    const url = a.attr("href");
    const slug = url.split("/")[4];
    const type = row.find(".search_img_nu > .search_ratings > span").text()
    const thumbnail = row.find("img").attr("src")
    const genres = row
        .find(".search_genre > .gennew")
        .map((_, g) => cheerio(g).text())
        .toArray();
    const rawDescription = row
        .find(".search_body_nu")
        .text()
        .replace(/\.\.\.\smore>>|<<less/gm, "")
        .trim();

    const description = rawDescription.split(genres.join(" "))[1].replace(/\n/gm, " ")
    const rating = row
        .find(".search_img_nu > .search_ratings")
        .text()
        .replace(/[()]/g, "")
        .replace(type, "")
        .trim()
    const updateDate = row.find(".search_body_nu > .search_stats > .ss_desk").last().text()

    return {
        id: parseInt(id, 10),
        slug,
        url,
        title: a.text(),
        description,
        thumbnail,
        averageRating: parseFloat(rating),
        type,
        genres,
        updateDate
    };
};

/**
 * @param {CheerioStatic} $
 */
const extractData = ($) => ({
    ...getPagination($),
    data: $(".search_main_box_nu")
        .map(parseRow)
        .toArray()
});

/**
 * @param {number} page
 * @returns {Promise<CheerioStatic>}
 */
const getPageWithData = async (page) => {
    const res = await axios(`https://www.novelupdates.com/novelslisting/?st=1&pg=${page}`);
    if (res.status >= 400) {
        throw new Error(res.statusText);
    }

    return cheerio.load(res.data);
};

/**
 * Parses novelslisting https://www.novelupdates.com/novelslisting
 *
 * TODO: filter/sort?
 * @param {number} page - novels listing page number
 */
const getSeriesList = (page = 1) => getPageWithData(page).then(extractData);

module.exports = getSeriesList;


text:
require 'spec_helper'

describe Massimo::Watcher do
  let(:site)    { Massimo::Site.new(:lib_path => 'libs') }
  let(:watcher) { Massimo::Watcher.new(site) }

  def with_files(check_once = true)
    within_construct do |construct|
      construct.file 'pages/index.haml'
      watcher.changed? if check_once
      yield construct
    end
  end

  describe '#changed?' do
    it 'returns false' do
      watcher.should_not be_changed
    end

    context 'when a file is added' do
      it 'returns true' do
        with_files(false) do |c|
          watcher.should be_changed
        end
      end

      context 'then checked without updates' do
        it 'returns false' do
          with_files do |c|
            watcher.should_not be_changed
          end
        end
      end
    end

    context 'when a file is removed' do
      it 'returns true' do
        with_files do |c|
          File.delete 'pages/index.haml'
          watcher.should be_changed
        end
      end
    end

    context 'when a file is updated' do
      it 'returns true' do
        with_files do |c|
          sleep 1
          File.open('pages/index.haml', 'w+') { |file| file.write('change') }
          watcher.should be_changed
        end
      end
    end
  end

  describe '#config_changed?' do
    it 'returns false' do
      watcher.should_not be_config_changed
    end

    context 'when a file is updated' do
      it 'returns false' do
        with_files do |c|
          sleep 1
          c.file 'pages/index.haml'
          watcher.should_not be_config_changed
        end
      end
    end

    context 'when the config file is updated' do
      it 'returns true' do
        within_construct do |c|
          c.file 'config.rb'
          watcher.config_changed?
          sleep 1
          c.file 'config.rb', 'config.output_path = "output"'
          watcher.should be_config_changed
        end
      end
    end
  end

  describe '#process' do
    context 'with changes' do
      it 'calls site#process' do
        mock(Massimo::Site.new).process
        watcher = Massimo::Watcher.new(Massimo.site)
        mock(watcher).changed? { true }
        watcher.process
      end
    end

    context 'with config changes' do
      it 'calls site#reload' do
        site = Massimo::Site.new
        mock(site).reload
        mock(site).process
        watcher = Massimo::Watcher.new(site)
        mock(watcher).config_changed? { true }
        watcher.process
      end
    end

    context 'without changes' do
      it 'does not call site#process' do
        dont_allow(Massimo::Site.new).process
        watcher = Massimo::Watcher.new(Massimo.site)
        mock(watcher).changed? { false }
        watcher.process
      end
    end
  end

  describe '.start' do
    it 'runs a new Watcher' do
      mock(watcher = Object.new).run
      mock(Massimo::Watcher).new(Massimo.site) { watcher }
      Massimo::Watcher.start(Massimo.site)
    end
  end
end


text:
fastlane documentation
================
# Installation
```
sudo gem install fastlane
```
# Available Actions
## iOS
### ios lint
```
fastlane ios lint
```
Runs linting
### ios test
```
fastlane ios test
```
Runs all the tests

----

This README.md is auto-generated and will be re-generated every time [fastlane](https://fastlane.tools) is run.
More information about fastlane can be found on [https://fastlane.tools](https://fastlane.tools).
The documentation of fastlane can be found on [GitHub](https://github.com/fastlane/fastlane/tree/master/fastlane).


text:
package com.artemis.component;

import com.artemis.PooledComponent;
import com.artemis.utils.Bag;

public class ReusedComponent extends PooledComponent
{
	public String data;

	@Override
	public void reset()
	{

	}
}


text:
<?php

defined('WEKIT_VERSION') || exit('Forbidden');

class PwDeleteTopicDoDirectDelete extends iPwGleanDoHookProcess
{
    protected $recode = [];

    public function gleanData($value)
    {
        if ($value['disabled'] == 2) {
            $this->recode[] = $value['tid'];
        }
    }

    public function run($ids)
    {
        $service = Wekit::load('forum.PwThread');
        $service->batchDeleteThread($ids);
        $service->batchDeletePostByTid($ids);

        if ($this->recode) {
            Wekit::load('recycle.PwTopicRecycle')->batchDelete($this->recode);
        }
    }
}


text:
layout: recipe
title: Lavender Ice Cream
from: All Recipes
fromurl: http://allrecipes.com/Recipe/Lavender-Ice-Cream/
time:  30 minutes
---

Ingredients:
------------

* 3 cups milk
* 2 stems of fresh lavender flowers
* 8 egg yolks
* 1 1/2 cups white sugar
* 3 cups heavy cream

<br>

Directions:
-----------

1. Heat the milk and lavender in a 3-quart saucepan over low heat until warmed through.
2. Remove from heat, and allow lavender to infuse for about 20 minutes. Remove flowers.
3. Beat the egg yolks and sugar together in large bowl.
4. Whisk the lavender-infused milk into the egg mixture, then pour it back into the saucepan.
5. Heat the mixture over low heat, whisking constantly, until the mixture thickens and can coat the back of a spoon, 7 to 10 minutes.
6. Remove from heat, and cool slightly, about 5 minutes. Stir in the heavy cream.
7. Transfer the mixture to a bowl, and chill in refrigerator at least 4 hours.
8. Pour the chilled mixture into an ice cream maker and freeze according to manufacturer's directions until it reaches "soft-serve" consistency. Transfer ice cream to a lidded container; cover surface with plastic wrap and seal. For best results, ice cream should be place in the freezer at least 2 hours or overnight.


text:
package com.trebuh.clarity.network;

import com.trebuh.clarity.models.PhotosResponse;

import retrofit2.Call;
import retrofit2.http.GET;
import retrofit2.http.Query;

// 500px service for use with Retrofit
public interface FiveHundredPxService {
    @GET("photos")
    Call<PhotosResponse> listPhotos(
            @Query(ApiConstants.PARAM_FEATURE) String feature,
            @Query(ApiConstants.PARAM_SORT_METHOD) String sortMethod,
            @Query(ApiConstants.PARAM_IMAGE_SIZE) String imageSize,
            @Query(ApiConstants.EXTRA_PAGE) int page,
            @Query(ApiConstants.EXTRA_RESULTS_PER_PAGE) int rpp,
            @Query(ApiConstants.PARAM_EXCLUDE) String exclude
    );

    @GET("photos/search")
    Call<PhotosResponse> searchPhotos(
            @Query(ApiConstants.PARAM_SORT_METHOD) String sortMethod,
            @Query(ApiConstants.PARAM_IMAGE_SIZE) String imageSize,
            @Query(ApiConstants.PARAM_EXCLUDE) String exclude,
            @Query(ApiConstants.PARAM_SEARCH_TERM) String searchTerm,
            @Query(ApiConstants.EXTRA_PAGE) int page,
            @Query(ApiConstants.EXTRA_RESULTS_PER_PAGE) int rpp
    );
}


text:
/*- 模型表单输入域的验证方法数据表 -*/
DROP TABLE IF EXISTS "modelengine_core_validation";
CREATE TABLE modelengine_core_validation (
    validation_id      INTEGER          PRIMARY KEY
                                        NOT NULL
                                        UNIQUE,
    model_code         NVARCHAR( 20 )   NOT NULL
                                        NOT NULL,
    form_id            INTEGER          NOT NULL
                                        DEFAULT ( 0 ),
    validation_method  NVARCHAR( 20 )   NOT NULL
                                        NOT NULL,
    validation_message NVARCHAR( 255 ),
    position_order     INTEGER          NOT NULL
                                        DEFAULT ( 0 ),
    update_time        INTEGER          NOT NULL,
    create_time        INTEGER          NOT NULL
);


text:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Uses of Interface com.cyc.base.cycobject.CycSentence (Core Client Implementation 1.1.1 API)</title>
<meta name="date" content="2018-01-24">
<link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">

JavaScript is disabled on your browser.

Skip navigation links

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

Cyc Core Client Implementation

Prev

Next

Frames

No Frames

All Classes

Uses of Interface
com.cyc.base.cycobject.CycSentence

Packages that use CycSentence

Package
Description

com.cyc.base.cycobject

Interfaces for representations of Knowledge Base objects such as constants, functional expressions, lists, rules and assertions; this code is not supported for external developers.

com.cyc.base.kbtool

Interfaces for common operations for KB content, such as assertion, querying, etc; this code is not supported for external developers.

com.cyc.baseclient.cycobject

Provides the attributes and behavior of Base Client API Knowledge Base objects such as
 constants, functional expressions, lists, rules and assertions; this code is not supported for external developers.

com.cyc.baseclient.kbtool

Classes which wrap common operations for KB content, such as assertion, querying, etc; this code is not supported for external developers.

Uses of CycSentence in com.cyc.base.cycobject

Subinterfaces of CycSentence in com.cyc.base.cycobject

Modifier and Type
Interface and Description

interface
FormulaSentence

A FormulaSentence is a Sentences composed of a truth function and a list of arguments.

Methods in com.cyc.base.cycobject that return CycSentence

Modifier and Type
Method and Description

CycSentence
FormulaSentence.getEqualsFoldedSentence(CycAccess access)

CycSentence
FormulaSentence.getEqualsFoldedSentence(CycAccess access,
                       ElMt mt)

CycSentence
FormulaSentence.getSimplifiedSentence(CycAccess access)

Get a simplified version of this sentence.

CycSentence
FormulaSentence.getSimplifiedSentence(CycAccess access,
                     ElMt mt)

Get a simplified version of this sentence.

Uses of CycSentence in com.cyc.base.kbtool

Methods in com.cyc.base.kbtool that return CycSentence

Modifier and Type
Method and Description

CycSentence
LookupTool.getSimplifiedSentence(FormulaSentence sentence)

CycSentence
LookupTool.getSimplifiedSentence(FormulaSentence sentence,
                     ElMt mt)

Uses of CycSentence in com.cyc.baseclient.cycobject

Classes in com.cyc.baseclient.cycobject that implement CycSentence

Modifier and Type
Class and Description

class
CycConstantSentenceImpl

CycConstantSentenceImpl is designed to be an object that represents Sentences that
 are single terms (the only known instance of this is #$False.)

class
FormulaSentenceImpl

Methods in com.cyc.baseclient.cycobject that return CycSentence

Modifier and Type
Method and Description

CycSentence
FormulaSentenceImpl.getEqualsFoldedSentence(CycAccess access)

CycSentence
FormulaSentenceImpl.getEqualsFoldedSentence(CycAccess access,
                       ElMt mt)

CycSentence
FormulaSentenceImpl.getSimplifiedSentence(CycAccess access)

CycSentence
FormulaSentenceImpl.getSimplifiedSentence(CycAccess access,
                     ElMt mt)

Uses of CycSentence in com.cyc.baseclient.kbtool

Methods in com.cyc.baseclient.kbtool that return CycSentence

Modifier and Type
Method and Description

CycSentence
LookupToolImpl.getSimplifiedSentence(FormulaSentence sentence)

CycSentence
LookupToolImpl.getSimplifiedSentence(FormulaSentence sentence,
                     ElMt mt)

Skip navigation links

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

Cyc Core Client Implementation

Prev

Next

Frames

No Frames

All Classes

Copyright © 2013–2018 Cycorp, Inc. All rights reserved.


text:
<?php
// $Header: /cvsroot/html2ps/css.color.inc.php,v 1.13 2007/01/24 18:55:51 Konstantin Exp $

class CSSColor extends CSSPropertyHandler {
  function CSSColor() {
    $this->CSSPropertyHandler(true, true);
  }

  function default_value() {
    return new Color(array(0,0,0),false);
  }

  function parse($value) {
    if ($value === 'inherit') {
      return CSS_PROPERTY_INHERIT;
    };

    return parse_color_declaration($value);
  }

  function get_property_code() {
    return CSS_COLOR;
  }

  function get_property_name() {
    return 'color';
  }
}

CSS::register_css_property(new CSSColor);

?>


text:
package com.insidecoding.sos.net;

/**
 * Object returned after Http calls.
 *
 * @author ludovicianul
 *
 */
public final class HttpResponse {
	/**
	 * The code of the response.
	 */
	private int responseCode;

	/**
	 * The content of the response.
	 */
	private String responseContent;

	/**
	 * Getter for responseCode.
	 *
	 * @return the response code
	 */
	public int getResponseCode() {
		return responseCode;
	}

	/**
	 * Setter for the response code.
	 *
	 * @param rspCode
	 *            the response code.
	 */
	public void setResponseCode(final int rspCode) {
		this.responseCode = rspCode;
	}

	/**
	 * Getter for the response content.
	 *
	 * @return the response content.
	 */
	public String getResponseContent() {
		return responseContent;
	}

	/**
	 * Setter for the response content.
	 *
	 * @param rspContent
	 *            the response content
	 */
	public void setResponseContent(final String rspContent) {
		this.responseContent = rspContent;
	}
}