Result:
found 484 distributions and 1145 files matching your query !
( run in 0.643 )
Crypt-Diceware-Wordlist-NL
view release on metacpan or search on metacpan
lib/Crypt/Diceware/Wordlist/NL.pm view on Meta::CPAN
15663 cool
15664 cordon
15665 corgi
15666 corner
16111 cornet
16112 corona
16113 corps
16114 corpus
16115 corso
16116 cortex
16121 corvee
Crypt-Diceware
view release on metacpan or search on metacpan
lib/Crypt/Diceware/Wordlist/Common.pm view on Meta::CPAN
contessa contest continual contort contrail contrary contrite contrive
control contumacy contuse contusion convene converge convert convex
convivial convolute convolve convoy convulse cookbook cooked cookie cookout
cool cooled cooperate coos coped copies copious copiously copout copped
copper coquette cordon cork corkscrew corm corn cornered cornice cornmeal
corollary coronet corporal corporate corporeal corps corpse corpulent
corpuscle correctly correlate corrode corroded corrosion corrosive
corrupted corset corseted cortical cosmetic cosmetics cosmic cosmogony
cosmology cosmonaut cosmos countess couplers courage course courser
courtesy cousin covenant cover covered covering covert covey cowardly cower
cowled coxswain coy cozying crabs crack cracked cracker crackers crackpot
lib/Crypt/Diceware/Wordlist/Common.pm view on Meta::CPAN
daunting dauntless daylight daypack daytime daywear dazed dazedly dazzle
dazzled dba deadened deadlock deafening deal dearest dearth debase
debatable debated debonair debrief debut decadence decagon decagram
decaliter decalogue decameter decamp decapod decayed deceit deceitful
deceive decency decent deception deceptive decide decides deciding
deciduous decimal decimate decipher decisive decker decks decorate decorous
decoy decoys decrease decreed decrepit decrying dedicate deduce deduces
deed deep deepen deepens deer deface defalcate defame defamed defanged
default defaults defective defendant defensive defer deference defiant
deficient defiled definite deflate deflates deflect deforest deform
deformed deformity defraud defray deft degrade degraded degrading dehydrate
Crypt-HSXKPasswd
view release on metacpan or search on metacpan
lib/Crypt/HSXKPasswd/Dictionary/ES.pm view on Meta::CPAN
'cornucopia',
'cornuda',
'cornudas',
'cornudo',
'cornudos',
'coro',
'corolaria',
'corolarias',
'corolario',
'corolarios',
'corona',
'coronaciones',
'coronación',
'coronado',
'coronamento',
'coronar',
'coronas',
'coronel',
'coroneles',
'coronilla',
'coronillas',
'coros',
'corpiño',
'corpiños',
'corporación',
'corporal',
'corporales',
lib/Crypt/HSXKPasswd/Dictionary/ES.pm view on Meta::CPAN
'decorasteis',
'decore',
'decoremos',
'decoren',
'decores',
'decoro',
'decoros',
'decorosa',
'decorosas',
'decoroso',
'decorosos',
'decorábamos',
'decoráis',
'decorándola',
'decorándolas',
'decorándolo',
lib/Crypt/HSXKPasswd/Dictionary/ES.pm view on Meta::CPAN
'indecisa',
'indecisas',
'indeciso',
'indecisos',
'indeclinable',
'indecorosa',
'indecorosas',
'indecoroso',
'indecorosos',
'indefectible',
'indefendible',
'indefensa',
'indefensas',
'indefensión',
lib/Crypt/HSXKPasswd/Dictionary/ES.pm view on Meta::CPAN
'licorera',
'licoreras',
'licores',
'licorista',
'licoristas',
'licorosa',
'licorosas',
'licoroso',
'licorosos',
'licuable',
'licuables',
'licuación',
'licuada',
'licuadas',
lib/Crypt/HSXKPasswd/Dictionary/ES.pm view on Meta::CPAN
'renca',
'rencas',
'renco',
'rencor',
'rencores',
'rencorosa',
'rencorosas',
'rencoroso',
'rencorosos',
'rencos',
'rendiciones',
'rendición',
'rendid',
'rendida',
Crypt-NSS-X509
view release on metacpan or search on metacpan
certs/root.ca view on Meta::CPAN
fY+BUZo7jYn0TZNmezwD7dOaHZrzZVD1oNB1ny+v8OqCQ5j4aZyJecRDjkZy42Q2Eq/3JR44iZB3
fsNrarnDy0RLrHiQi+fHLB5LEUTINFInzQpdn4XBidUaePKVEFMy3YCEZnXZtWgo+2EuvoSoOMCZ
EoalHmdkrQYuL6lwhceWD3yJZfWOQ1QOq92lgDmUYMA0yZZwLKMS9R9Ie70cfmu3nZD0Ijuu+Pwq
yvqCUqDvr0tVk+vBtfAii6w0TiYiBKGHLHVKt+V9E9e4DGTANtLJL4YSjCMJwRuCO3NJo2pXh5Tl
1njFmUNj403gdy3hZZlyaQQaRwnmDwFWJPsfvw55qVguucQJAX6Vum0ABj6y6koQOdjQK/W/7HW/
lwLFCRsI3FU34oH7N4RDYiDK51ZLZer+bMEkkyShNOsF/5oirpt9P/FlUQqmMGqz9IgcgA38coro
g14=
-----END CERTIFICATE-----
Taiwan GRCA
===========
Crypt-XkcdPassword
view release on metacpan or search on metacpan
lib/Crypt/XkcdPassword/Words/EN.pm view on Meta::CPAN
edgy
donkey
diseases
didn
curtis
coroner
confessing
cologne
cedar
ca
bruise
CtrlO-Crypt-XkcdPassword
view release on metacpan or search on metacpan
lib/CtrlO/Crypt/XkcdPassword/Wordlist/eff_large.pm view on Meta::CPAN
cornflake
cornhusk
cornmeal
cornstalk
corny
coronary
coroner
corporal
corporate
corral
correct
corridor
DBD-SQLcipher
view release on metacpan or search on metacpan
#define SQLITE_FactorOutConst 0x0008 /* Constant factoring */
/* not used 0x0010 // Was: SQLITE_IdxRealAsInt */
#define SQLITE_DistinctOpt 0x0020 /* DISTINCT using indexes */
#define SQLITE_CoverIdxScan 0x0040 /* Covering index scans */
#define SQLITE_OrderByIdxJoin 0x0080 /* ORDER BY of joins via index */
#define SQLITE_SubqCoroutine 0x0100 /* Evaluate subqueries as coroutines */
#define SQLITE_Transitive 0x0200 /* Transitive constraints */
#define SQLITE_OmitNoopJoin 0x0400 /* Omit unused tables in joins */
#define SQLITE_Stat34 0x0800 /* Use STAT3 or STAT4 data */
#define SQLITE_AllOpts 0xffff /* All optimizations */
break;
}
/* Opcode: InitCoroutine P1 P2 P3 * *
**
** Set up register P1 so that it will Yield to the coroutine
** located at address P3.
**
** If P2!=0 then the coroutine implementation immediately follows
** this opcode. So jump over the coroutine implementation to
** address P2.
**
** See also: EndCoroutine
*/
case OP_InitCoroutine: { /* jump */
}
/* Opcode: Yield P1 P2 * * *
**
** Swap the program counter with the value in register P1. This
** has the effect of yielding to a coroutine.
**
** If the coroutine that is launched by this instruction ends with
** Yield or Return then continue to the next instruction. But if
** the coroutine launched by this instruction ends with
** EndCoroutine, then jump to P2 rather than continuing with the
** next instruction.
**
** See also: InitCoroutine
*/
** loop over the rows in the SELECT
** load values into registers R..R+n
** yield X
** end loop
** cleanup after the SELECT
** end-coroutine X
** B: open write cursor to <table> and its indices
** C: yield X, at EOF goto D
** insert the select result into <table> from R..R+n
** goto C
** D: cleanup
if( pTrigger || readsTable(pParse, iDb, pTab) ){
useTempTable = 1;
}
if( useTempTable ){
/* Invoke the coroutine to extract information from the SELECT
** and add it to a transient table srcTab. The code generated
** here is from the 4th template:
**
** B: open temp table
** L: yield X, goto M at EOF
return rc;
}
#endif /* SQLITE_OMIT_COMPOUND_SELECT */
/*
** Code an output subroutine for a coroutine implementation of a
** SELECT statment.
**
** The data to be output is contained in pIn->iSdst. There are
** pIn->nSdst columns to be output. pDest is where the output should
** be sent.
** <selectA> <operator> <selectB> ORDER BY <orderbylist>
**
** <operator> is one of UNION ALL, UNION, EXCEPT, or INTERSECT. The idea
** is to code both <selectA> and <selectB> with the ORDER BY clause as
** co-routines. Then run the co-routines in parallel and merge the results
** into the output. In addition to the two coroutines (called selectA and
** selectB) there are 7 subroutines:
**
** outA: Move the output of the selectA coroutine into the output
** of the compound query.
**
** outB: Move the output of the selectB coroutine into the output
** of the compound query. (Only generated for UNION and
** UNION ALL. EXCEPT and INSERTSECT never output a row that
** appears only in B.)
**
** AltB: Called when there is data from both coroutines and A<B.
**
** AeqB: Called when there is data from both coroutines and A==B.
**
** AgtB: Called when there is data from both coroutines and A>B.
**
** EofA: Called when data is exhausted from selectA.
**
** EofB: Called when data is exhausted from selectB.
**
** Duplicate removal in the UNION, EXCEPT, and INTERSECT cases is handled
** within the output subroutine. The regPrev register set holds the previously
** output value. A comparison is made against this value and the output
** is skipped if the next results would be the same as the previous.
**
** The implementation plan is to implement the two coroutines and seven
** subroutines first, then put the control logic at the bottom. Like this:
**
** goto Init
** coA: coroutine for left query (A)
** coB: coroutine for right query (B)
** outA: output one row of A
** outB: output one row of B (UNION and UNION ALL only)
** EofA: ...
** EofB: ...
** AltB: ...
** AeqB: ...
** AgtB: ...
** Init: initialize coroutine registers
** yield coA
** if eof(A) goto EofA
** yield coB
** if eof(B) goto EofB
** Cmpr: Compare A, B
SelectDest *pDest /* What to do with query results */
){
int i, j; /* Loop counters */
Select *pPrior; /* Another SELECT immediately to our left */
Vdbe *v; /* Generate code to this VDBE */
SelectDest destA; /* Destination for coroutine A */
SelectDest destB; /* Destination for coroutine B */
int regAddrA; /* Address register for select-A coroutine */
int regAddrB; /* Address register for select-B coroutine */
int addrSelectA; /* Address of the select-A coroutine */
int addrSelectB; /* Address of the select-B coroutine */
int regOutA; /* Address register for the output-A subroutine */
int regOutB; /* Address register for the output-B subroutine */
int addrOutA; /* Address of the output-A subroutine */
int addrOutB = 0; /* Address of the output-B subroutine */
int addrEofA; /* Address of the select-A-exhausted subroutine */
regOutA = ++pParse->nMem;
regOutB = ++pParse->nMem;
sqlite3SelectDestInit(&destA, SRT_Coroutine, regAddrA);
sqlite3SelectDestInit(&destB, SRT_Coroutine, regAddrB);
/* Generate a coroutine to evaluate the SELECT statement to the
** left of the compound operator - the "A" select.
*/
addrSelectA = sqlite3VdbeCurrentAddr(v) + 1;
j1 = sqlite3VdbeAddOp3(v, OP_InitCoroutine, regAddrA, 0, addrSelectA);
VdbeComment((v, "left SELECT"));
explainSetInteger(iSub1, pParse->iNextSelectId);
sqlite3Select(pParse, pPrior, &destA);
sqlite3VdbeAddOp1(v, OP_EndCoroutine, regAddrA);
sqlite3VdbeJumpHere(v, j1);
/* Generate a coroutine to evaluate the SELECT statement on
** the right - the "B" select
*/
addrSelectB = sqlite3VdbeCurrentAddr(v) + 1;
j1 = sqlite3VdbeAddOp3(v, OP_InitCoroutine, regAddrB, 0, addrSelectB);
VdbeComment((v, "right SELECT"));
DBD-SQLeet
view release on metacpan or search on metacpan
break;
}
/* Opcode: InitCoroutine P1 P2 P3 * *
**
** Set up register P1 so that it will Yield to the coroutine
** located at address P3.
**
** If P2!=0 then the coroutine implementation immediately follows
** this opcode. So jump over the coroutine implementation to
** address P2.
**
** See also: EndCoroutine
*/
case OP_InitCoroutine: { /* jump */
}
/* Opcode: Yield P1 P2 * * *
**
** Swap the program counter with the value in register P1. This
** has the effect of yielding to a coroutine.
**
** If the coroutine that is launched by this instruction ends with
** Yield or Return then continue to the next instruction. But if
** the coroutine launched by this instruction ends with
** EndCoroutine, then jump to P2 rather than continuing with the
** next instruction.
**
** See also: InitCoroutine
*/
** loop over the rows in the SELECT
** load values into registers R..R+n
** yield X
** end loop
** cleanup after the SELECT
** end-coroutine X
** B: open write cursor to <table> and its indices
** C: yield X, at EOF goto D
** insert the select result into <table> from R..R+n
** goto C
** D: cleanup
if( pTrigger || readsTable(pParse, iDb, pTab) ){
useTempTable = 1;
}
if( useTempTable ){
/* Invoke the coroutine to extract information from the SELECT
** and add it to a transient table srcTab. The code generated
** here is from the 4th template:
**
** B: open temp table
** L: yield X, goto M at EOF
" do not have the same number of result columns", selectOpName(p->op));
}
}
/*
** Code an output subroutine for a coroutine implementation of a
** SELECT statment.
**
** The data to be output is contained in pIn->iSdst. There are
** pIn->nSdst columns to be output. pDest is where the output should
** be sent.
** <selectA> <operator> <selectB> ORDER BY <orderbylist>
**
** <operator> is one of UNION ALL, UNION, EXCEPT, or INTERSECT. The idea
** is to code both <selectA> and <selectB> with the ORDER BY clause as
** co-routines. Then run the co-routines in parallel and merge the results
** into the output. In addition to the two coroutines (called selectA and
** selectB) there are 7 subroutines:
**
** outA: Move the output of the selectA coroutine into the output
** of the compound query.
**
** outB: Move the output of the selectB coroutine into the output
** of the compound query. (Only generated for UNION and
** UNION ALL. EXCEPT and INSERTSECT never output a row that
** appears only in B.)
**
** AltB: Called when there is data from both coroutines and A<B.
**
** AeqB: Called when there is data from both coroutines and A==B.
**
** AgtB: Called when there is data from both coroutines and A>B.
**
** EofA: Called when data is exhausted from selectA.
**
** EofB: Called when data is exhausted from selectB.
**
** Duplicate removal in the UNION, EXCEPT, and INTERSECT cases is handled
** within the output subroutine. The regPrev register set holds the previously
** output value. A comparison is made against this value and the output
** is skipped if the next results would be the same as the previous.
**
** The implementation plan is to implement the two coroutines and seven
** subroutines first, then put the control logic at the bottom. Like this:
**
** goto Init
** coA: coroutine for left query (A)
** coB: coroutine for right query (B)
** outA: output one row of A
** outB: output one row of B (UNION and UNION ALL only)
** EofA: ...
** EofB: ...
** AltB: ...
** AeqB: ...
** AgtB: ...
** Init: initialize coroutine registers
** yield coA
** if eof(A) goto EofA
** yield coB
** if eof(B) goto EofB
** Cmpr: Compare A, B
SelectDest *pDest /* What to do with query results */
){
int i, j; /* Loop counters */
Select *pPrior; /* Another SELECT immediately to our left */
Vdbe *v; /* Generate code to this VDBE */
SelectDest destA; /* Destination for coroutine A */
SelectDest destB; /* Destination for coroutine B */
int regAddrA; /* Address register for select-A coroutine */
int regAddrB; /* Address register for select-B coroutine */
int addrSelectA; /* Address of the select-A coroutine */
int addrSelectB; /* Address of the select-B coroutine */
int regOutA; /* Address register for the output-A subroutine */
int regOutB; /* Address register for the output-B subroutine */
int addrOutA; /* Address of the output-A subroutine */
int addrOutB = 0; /* Address of the output-B subroutine */
int addrEofA; /* Address of the select-A-exhausted subroutine */
sqlite3SelectDestInit(&destA, SRT_Coroutine, regAddrA);
sqlite3SelectDestInit(&destB, SRT_Coroutine, regAddrB);
ExplainQueryPlan((pParse, 1, "MERGE (%s)", selectOpName(p->op)));
/* Generate a coroutine to evaluate the SELECT statement to the
** left of the compound operator - the "A" select.
*/
addrSelectA = sqlite3VdbeCurrentAddr(v) + 1;
addr1 = sqlite3VdbeAddOp3(v, OP_InitCoroutine, regAddrA, 0, addrSelectA);
VdbeComment((v, "left SELECT"));
ExplainQueryPlan((pParse, 1, "LEFT"));
sqlite3Select(pParse, pPrior, &destA);
sqlite3VdbeEndCoroutine(v, regAddrA);
sqlite3VdbeJumpHere(v, addr1);
/* Generate a coroutine to evaluate the SELECT statement on
** the right - the "B" select
*/
addrSelectB = sqlite3VdbeCurrentAddr(v) + 1;
addr1 = sqlite3VdbeAddOp3(v, OP_InitCoroutine, regAddrB, 0, addrSelectB);
VdbeComment((v, "right SELECT"));
DBD-SQLite-Amalgamation
view release on metacpan or search on metacpan
sqlite-amalgamation.c view on Meta::CPAN
int endOfLoop; /* Label for the end of the insertion loop */
int useTempTable = 0; /* Store SELECT results in intermediate table */
int srcTab = 0; /* Data comes from this temporary cursor if >=0 */
int addrInsTop = 0; /* Jump to label "D" */
int addrCont = 0; /* Top of insert loop. Label "C" in templates 3 and 4 */
int addrSelect = 0; /* Address of coroutine that implements the SELECT */
SelectDest dest; /* Destination for SELECT on rhs of INSERT */
int newIdx = -1; /* Cursor for the NEW pseudo-table */
int iDb; /* Index of database holding TABLE */
Db *pDb; /* The database containing table being inserted into */
int appendFlag = 0; /* True if the insert is likely to be an append */
sqlite-amalgamation.c view on Meta::CPAN
VdbeComment((v, "SELECT eof flag"));
sqlite3SelectDestInit(&dest, SRT_Coroutine, ++pParse->nMem);
addrSelect = sqlite3VdbeCurrentAddr(v)+2;
sqlite3VdbeAddOp2(v, OP_Integer, addrSelect-1, dest.iParm);
j1 = sqlite3VdbeAddOp2(v, OP_Goto, 0, 0);
VdbeComment((v, "Jump over SELECT coroutine"));
/* Resolve the expressions in the SELECT statement and execute it. */
rc = sqlite3Select(pParse, pSelect, &dest, 0, 0, 0);
if( rc || pParse->nErr || db->mallocFailed ){
goto insert_cleanup;
}
sqlite3VdbeAddOp2(v, OP_Integer, 1, regEof); /* EOF <- 1 */
sqlite3VdbeAddOp1(v, OP_Yield, dest.iParm); /* yield X */
sqlite3VdbeAddOp2(v, OP_Halt, SQLITE_INTERNAL, OE_Abort);
VdbeComment((v, "End of SELECT coroutine"));
sqlite3VdbeJumpHere(v, j1); /* label B: */
regFromSelect = dest.iMem;
assert( pSelect->pEList );
nColumn = pSelect->pEList->nExpr;
sqlite-amalgamation.c view on Meta::CPAN
if( triggers_exist || readsTable(v, addrSelect, iDb, pTab) ){
useTempTable = 1;
}
if( useTempTable ){
/* Invoke the coroutine to extract information from the SELECT
** and add it to a transient table srcTab. The code generated
** here is from the 4th template:
**
** B: open temp table
** L: yield X
sqlite-amalgamation.c view on Meta::CPAN
return rc;
}
#endif /* SQLITE_OMIT_COMPOUND_SELECT */
/*
** Code an output subroutine for a coroutine implementation of a
** SELECT statment.
**
** The data to be output is contained in pIn->iMem. There are
** pIn->nMem columns to be output. pDest is where the output should
** be sent.
sqlite-amalgamation.c view on Meta::CPAN
** <selectA> <operator> <selectB> ORDER BY <orderbylist>
**
** <operator> is one of UNION ALL, UNION, EXCEPT, or INTERSECT. The idea
** is to code both <selectA> and <selectB> with the ORDER BY clause as
** co-routines. Then run the co-routines in parallel and merge the results
** into the output. In addition to the two coroutines (called selectA and
** selectB) there are 7 subroutines:
**
** outA: Move the output of the selectA coroutine into the output
** of the compound query.
**
** outB: Move the output of the selectB coroutine into the output
** of the compound query. (Only generated for UNION and
** UNION ALL. EXCEPT and INSERTSECT never output a row that
** appears only in B.)
**
** AltB: Called when there is data from both coroutines and A<B.
**
** AeqB: Called when there is data from both coroutines and A==B.
**
** AgtB: Called when there is data from both coroutines and A>B.
**
** EofA: Called when data is exhausted from selectA.
**
** EofB: Called when data is exhausted from selectB.
**
sqlite-amalgamation.c view on Meta::CPAN
** Duplicate removal in the UNION, EXCEPT, and INTERSECT cases is handled
** within the output subroutine. The regPrev register set holds the previously
** output value. A comparison is made against this value and the output
** is skipped if the next results would be the same as the previous.
**
** The implementation plan is to implement the two coroutines and seven
** subroutines first, then put the control logic at the bottom. Like this:
**
** goto Init
** coA: coroutine for left query (A)
** coB: coroutine for right query (B)
** outA: output one row of A
** outB: output one row of B (UNION and UNION ALL only)
** EofA: ...
** EofB: ...
** AltB: ...
** AeqB: ...
** AgtB: ...
** Init: initialize coroutine registers
** yield coA
** if eof(A) goto EofA
** yield coB
** if eof(B) goto EofB
** Cmpr: Compare A, B
sqlite-amalgamation.c view on Meta::CPAN
SelectDest *pDest /* What to do with query results */
){
int i, j; /* Loop counters */
Select *pPrior; /* Another SELECT immediately to our left */
Vdbe *v; /* Generate code to this VDBE */
SelectDest destA; /* Destination for coroutine A */
SelectDest destB; /* Destination for coroutine B */
int regAddrA; /* Address register for select-A coroutine */
int regEofA; /* Flag to indicate when select-A is complete */
int regAddrB; /* Address register for select-B coroutine */
int regEofB; /* Flag to indicate when select-B is complete */
int addrSelectA; /* Address of the select-A coroutine */
int addrSelectB; /* Address of the select-B coroutine */
int regOutA; /* Address register for the output-A subroutine */
int regOutB; /* Address register for the output-B subroutine */
int addrOutA; /* Address of the output-A subroutine */
int addrOutB; /* Address of the output-B subroutine */
int addrEofA; /* Address of the select-A-exhausted subroutine */
sqlite-amalgamation.c view on Meta::CPAN
regOutA = ++pParse->nMem;
regOutB = ++pParse->nMem;
sqlite3SelectDestInit(&destA, SRT_Coroutine, regAddrA);
sqlite3SelectDestInit(&destB, SRT_Coroutine, regAddrB);
/* Jump past the various subroutines and coroutines to the main
** merge loop
*/
j1 = sqlite3VdbeAddOp0(v, OP_Goto);
addrSelectA = sqlite3VdbeCurrentAddr(v);
/* Generate a coroutine to evaluate the SELECT statement to the
** left of the compound operator - the "A" select.
*/
VdbeNoopComment((v, "Begin coroutine for left SELECT"));
pPrior->iLimit = regLimitA;
sqlite3Select(pParse, pPrior, &destA, 0, 0, 0);
sqlite3VdbeAddOp2(v, OP_Integer, 1, regEofA);
sqlite3VdbeAddOp1(v, OP_Yield, regAddrA);
VdbeNoopComment((v, "End coroutine for left SELECT"));
/* Generate a coroutine to evaluate the SELECT statement on
** the right - the "B" select
*/
addrSelectB = sqlite3VdbeCurrentAddr(v);
VdbeNoopComment((v, "Begin coroutine for right SELECT"));
savedLimit = p->iLimit;
savedOffset = p->iOffset;
p->iLimit = regLimitB;
p->iOffset = 0;
sqlite3Select(pParse, p, &destB, 0, 0, 0);
p->iLimit = savedLimit;
p->iOffset = savedOffset;
sqlite3VdbeAddOp2(v, OP_Integer, 1, regEofB);
sqlite3VdbeAddOp1(v, OP_Yield, regAddrB);
VdbeNoopComment((v, "End coroutine for right SELECT"));
/* Generate a subroutine that outputs the current row of the A
** select as the next output row of the compound select.
*/
VdbeNoopComment((v, "Output routine for A"));
DBD-SQLite
view release on metacpan or search on metacpan
break;
}
/* Opcode: InitCoroutine P1 P2 P3 * *
**
** Set up register P1 so that it will Yield to the coroutine
** located at address P3.
**
** If P2!=0 then the coroutine implementation immediately follows
** this opcode. So jump over the coroutine implementation to
** address P2.
**
** See also: EndCoroutine
*/
case OP_InitCoroutine: { /* jump0 */
}
/* Opcode: Yield P1 P2 * * *
**
** Swap the program counter with the value in register P1. This
** has the effect of yielding to a coroutine.
**
** If the coroutine that is launched by this instruction ends with
** Yield or Return then continue to the next instruction. But if
** the coroutine launched by this instruction ends with
** EndCoroutine, then jump to P2 rather than continuing with the
** next instruction.
**
** See also: InitCoroutine
*/
** loop over the rows in the SELECT
** load values into registers R..R+n
** yield X
** end loop
** cleanup after the SELECT
** end-coroutine X
** B: open write cursor to <table> and its indices
** C: yield X, at EOF goto D
** insert the select result into <table> from R..R+n
** goto C
** D: cleanup
if( pTrigger || readsTable(pParse, iDb, pTab) ){
useTempTable = 1;
}
if( useTempTable ){
/* Invoke the coroutine to extract information from the SELECT
** and add it to a transient table srcTab. The code generated
** here is from the 4th template:
**
** B: open temp table
** L: yield X, goto M at EOF
sqlite3SelectOpName(p->op));
}
}
/*
** Code an output subroutine for a coroutine implementation of a
** SELECT statement.
**
** The data to be output is contained in pIn->iSdst. There are
** pIn->nSdst columns to be output. pDest is where the output should
** be sent.
** <selectA> <operator> <selectB> ORDER BY <orderbylist>
**
** <operator> is one of UNION ALL, UNION, EXCEPT, or INTERSECT. The idea
** is to code both <selectA> and <selectB> with the ORDER BY clause as
** co-routines. Then run the co-routines in parallel and merge the results
** into the output. In addition to the two coroutines (called selectA and
** selectB) there are 7 subroutines:
**
** outA: Move the output of the selectA coroutine into the output
** of the compound query.
**
** outB: Move the output of the selectB coroutine into the output
** of the compound query. (Only generated for UNION and
** UNION ALL. EXCEPT and INSERTSECT never output a row that
** appears only in B.)
**
** AltB: Called when there is data from both coroutines and A<B.
**
** AeqB: Called when there is data from both coroutines and A==B.
**
** AgtB: Called when there is data from both coroutines and A>B.
**
** EofA: Called when data is exhausted from selectA.
**
** EofB: Called when data is exhausted from selectB.
**
** Duplicate removal in the UNION, EXCEPT, and INTERSECT cases is handled
** within the output subroutine. The regPrev register set holds the previously
** output value. A comparison is made against this value and the output
** is skipped if the next results would be the same as the previous.
**
** The implementation plan is to implement the two coroutines and seven
** subroutines first, then put the control logic at the bottom. Like this:
**
** goto Init
** coA: coroutine for left query (A)
** coB: coroutine for right query (B)
** outA: output one row of A
** outB: output one row of B (UNION and UNION ALL only)
** EofA: ...
** EofB: ...
** AltB: ...
** AeqB: ...
** AgtB: ...
** Init: initialize coroutine registers
** yield coA
** if eof(A) goto EofA
** yield coB
** if eof(B) goto EofB
** Cmpr: Compare A, B
int i, j; /* Loop counters */
Select *pPrior; /* Another SELECT immediately to our left */
Select *pSplit; /* Left-most SELECT in the right-hand group */
int nSelect; /* Number of SELECT statements in the compound */
Vdbe *v; /* Generate code to this VDBE */
SelectDest destA; /* Destination for coroutine A */
SelectDest destB; /* Destination for coroutine B */
int regAddrA; /* Address register for select-A coroutine */
int regAddrB; /* Address register for select-B coroutine */
int addrSelectA; /* Address of the select-A coroutine */
int addrSelectB; /* Address of the select-B coroutine */
int regOutA; /* Address register for the output-A subroutine */
int regOutB; /* Address register for the output-B subroutine */
int addrOutA; /* Address of the output-A subroutine */
int addrOutB = 0; /* Address of the output-B subroutine */
int addrEofA; /* Address of the select-A-exhausted subroutine */
sqlite3SelectDestInit(&destA, SRT_Coroutine, regAddrA);
sqlite3SelectDestInit(&destB, SRT_Coroutine, regAddrB);
ExplainQueryPlan((pParse, 1, "MERGE (%s)", sqlite3SelectOpName(p->op)));
/* Generate a coroutine to evaluate the SELECT statement to the
** left of the compound operator - the "A" select.
*/
addrSelectA = sqlite3VdbeCurrentAddr(v) + 1;
addr1 = sqlite3VdbeAddOp3(v, OP_InitCoroutine, regAddrA, 0, addrSelectA);
VdbeComment((v, "left SELECT"));
ExplainQueryPlan((pParse, 1, "LEFT"));
sqlite3Select(pParse, pPrior, &destA);
sqlite3VdbeEndCoroutine(v, regAddrA);
sqlite3VdbeJumpHere(v, addr1);
/* Generate a coroutine to evaluate the SELECT statement on
** the right - the "B" select
*/
addrSelectB = sqlite3VdbeCurrentAddr(v) + 1;
addr1 = sqlite3VdbeAddOp3(v, OP_InitCoroutine, regAddrB, 0, addrSelectB);
VdbeComment((v, "right SELECT"));
DBD_SQLFLEX
view release on metacpan or search on metacpan
You can then install using the new version's makefile. It is important
to use the correct (old or new) makefiles because the installed files
may be different, and if some file is made obsolete by the new version
(is not used by the new version), its makefile will not uninstall the
obsolete file; over time and multiple versions, this could, eventually,
lead to 'coronary thrombosis' on your disk drive -- or disk full.
KNOWN PROBLEMS:
None at this time.
DBI
view release on metacpan or search on metacpan
ex/corogofer.pl view on Meta::CPAN
BEGIN { $ENV{DBI_TRACE} = 0; $ENV{DBI_PUREPERL} = 0; $ENV{DBI_GOFER_TRACE} = 0; $ENV{DBD_GOFER_TRACE} = 0; };
use DBI;
$ENV{DBI_AUTOPROXY} = 'dbi:Gofer:transport=corostream';
my $ticker = AnyEvent->timer( after => 0, interval => 0.1, cb => sub {
warn sprintf "-tick- %.2f\n", time
} );
DBIx-Class-CustomPrefetch
view release on metacpan or search on metacpan
Debian_CPANTS.txt view on Meta::CPAN
"libconvert-binary-c-perl", "Convert-Binary-C", "0.74", "0", "0"
"libconvert-binhex-perl", "Convert-BinHex", "1.119", "1", "0"
"libconvert-color-perl", "Convert-Color", "0.05", "0", "0"
"libconvert-pem-perl", "Convert-PEM", "0.07", "1", "0"
"libconvert-uulib-perl", "Convert-UUlib", "1.12", "1", "0"
"libcoro-perl", "Coro", "5.200", "0", "0"
"libcoy-perl", "Coy", "0.06", "0", "0"
"libcpan-checksums-perl", "CPAN-Checksums", "2.03", "0", "0"
"libcpan-distnameinfo-perl", "CPAN-DistnameInfo", "0.08", "0", "0"
"libcpan-inject-perl", "CPAN-Inject", "0.11", "0", "0"
"libcpan-mini-perl", "CPAN-Mini", "0.576", "0", "0"
Debian_CPANTS.txt view on Meta::CPAN
"libnet-rawip-perl", "Net-RawIP", "0.25", "0", "0"
"libnet-rblclient-perl", "Net-RBLClient", "0.5", "0", "0"
"libnet-rendezvous-publish-backend-avahi-perl", "Net-Rendezvous-Publish-Backend-Avahi", "0.03", "0", "0"
"libnet-rendezvous-publish-perl", "Net-Rendezvous-Publish", "0.04", "0", "0"
"libnet-scp-expect-perl", "Net-SCP-Expect", "0.16", "0", "0"
"libnet-server-coro-perl", "Net-Server-Coro", "not-uploaded", "0", "0"
"libnet-sftp-foreign-perl", "Net-SFTP-Foreign", "1.55", "0", "0"
"libnet-sieve-perl", "Net-Sieve", "0.05", "0", "0"
"libnet-sieve-script-perl", "Net-Sieve-Script", "0.08", "0", "0"
"libnet-sip-perl", "Net-SIP", "0.54", "0", "0"
"libnet-smpp-perl", "Net-SMPP", "1.12", "0", "0"
DBIx-Class-DeploymentAdapter
view release on metacpan or search on metacpan
cpanfile.snapshot view on Meta::CPAN
DBD::Gofer::Policy::Base 0.010088
DBD::Gofer::Policy::classic 0.010088
DBD::Gofer::Policy::pedantic 0.010088
DBD::Gofer::Policy::rush 0.010088
DBD::Gofer::Transport::Base 0.014121
DBD::Gofer::Transport::corostream undef
DBD::Gofer::Transport::null 0.010088
DBD::Gofer::Transport::pipeone 0.010088
DBD::Gofer::Transport::stream 0.014599
DBD::Gofer::db 0.015327
DBD::Gofer::dr 0.015327
DBIx-Class-ElasticSync
view release on metacpan or search on metacpan
cpanfile.snapshot view on Meta::CPAN
DBD::Gofer::Policy::Base 0.010088
DBD::Gofer::Policy::classic 0.010088
DBD::Gofer::Policy::pedantic 0.010088
DBD::Gofer::Policy::rush 0.010088
DBD::Gofer::Transport::Base 0.014121
DBD::Gofer::Transport::corostream undef
DBD::Gofer::Transport::null 0.010088
DBD::Gofer::Transport::pipeone 0.010088
DBD::Gofer::Transport::stream 0.014599
DBD::Gofer::db 0.015327
DBD::Gofer::dr 0.015327
DBIx-Class-ParseError
view release on metacpan or search on metacpan
cpanfile.snapshot view on Meta::CPAN
DBD::Gofer::Policy::Base 0.010088
DBD::Gofer::Policy::classic 0.010088
DBD::Gofer::Policy::pedantic 0.010088
DBD::Gofer::Policy::rush 0.010088
DBD::Gofer::Transport::Base 0.014121
DBD::Gofer::Transport::corostream undef
DBD::Gofer::Transport::null 0.010088
DBD::Gofer::Transport::pipeone 0.010088
DBD::Gofer::Transport::stream 0.014599
DBD::Gofer::db 0.015327
DBD::Gofer::dr 0.015327
DBIx-Class-Validation-Structure
view release on metacpan or search on metacpan
cpanfile.snapshot view on Meta::CPAN
DBD::Gofer::Policy::Base 0.010088
DBD::Gofer::Policy::classic 0.010088
DBD::Gofer::Policy::pedantic 0.010088
DBD::Gofer::Policy::rush 0.010088
DBD::Gofer::Transport::Base 0.014121
DBD::Gofer::Transport::corostream undef
DBD::Gofer::Transport::null 0.010088
DBD::Gofer::Transport::pipeone 0.010088
DBD::Gofer::Transport::stream 0.014599
DBD::Gofer::db 0.015327
DBD::Gofer::dr 0.015327
DBIx-MysqlCoroAnyEvent
view release on metacpan or search on metacpan
# dbd-mysql-cae
DBD::mysql for coro+ae
DR-Tarantool
view release on metacpan or search on metacpan
lib/DR/Tarantool.pm view on Meta::CPAN
}
;
$tnt->update( ... );
my $tnt = coro_tarantool
host => '127.0.0.1',
port => 123,
spaces => {
...
}
lib/DR/Tarantool.pm view on Meta::CPAN
Is also built on top of L<DR::Tarantool::AsyncClient>, but is
designed to work in cooperative multitasking environment provided
by L<Coro>. Is fully syntax-compatible with
L<DR::Tarantool::SyncClient>, but requires a running event loop to
operate, like L<DR::Tarantool::AsyncClient>. Requests from
different coroutines are served concurrently.
=back
L<Tarantool|http://tarantool.org> binary protocol
contains no representation of database schema or tuple field types.
lib/DR/Tarantool.pm view on Meta::CPAN
use base qw(Exporter);
our %EXPORT_TAGS = (
client => [ qw( tarantool async_tarantool coro_tarantool) ],
constant => [
qw(
TNT_INSERT TNT_SELECT TNT_UPDATE TNT_DELETE TNT_CALL TNT_PING
TNT_FLAG_RETURN TNT_FLAG_ADD TNT_FLAG_REPLACE
)
lib/DR/Tarantool.pm view on Meta::CPAN
};
goto \&async_tarantool;
}
=head2 coro_tarantol
connects to L<tarantool|http://tarantool.org> in async mode using
L<DR::Tarantool::CoroClient>.
=cut
sub coro_tarantool {
require DR::Tarantool::CoroClient;
no warnings 'redefine';
*coro_tarantool = sub {
DR::Tarantool::CoroClient->connect(@_);
};
goto \&coro_tarantool;
}
=head2 :constant
DR-TarantoolQueue
view release on metacpan or search on metacpan
benchmark/1.5/channel.pl view on Meta::CPAN
);
sub tnt {
our $tnt;
unless(defined $tnt) {
$tnt = coro_tarantool
host => 'localhost',
port => $t->primary_port,
spaces => {}
;
}
DR-Tnt
view release on metacpan or search on metacpan
lib/DR/Tnt.pm view on Meta::CPAN
sub tarantool {
my (%opts) = @_;
my $driver = delete($opts{driver}) || 'sync';
unless (any { $driver eq $_ } 'sync', 'ae', 'async', 'coro') {
goto usage;
}
goto $driver;
lib/DR/Tnt.pm view on Meta::CPAN
ae:
async:
require DR::Tnt::Client::AE;
return DR::Tnt::Client::AE->new(%opts);
coro:
require DR::Tnt::Client::Coro;
return DR::Tnt::Client::Coro->new(%opts);
usage:
lib/DR/Tnt.pm view on Meta::CPAN
=item ae or async
L<DR::Tnt::Client::AE> will be loaded and created.
=item coro
L<DR::Tnt::Client::Coro> will be loaded and created.
=back
lib/DR/Tnt.pm view on Meta::CPAN
Internal to reconnect after disconnect or fatal errors. Undefined value
disables the mechanizm.
=item raise_error
The option is actual for C<coro> and C<sync> drivers
(L<DR::Tnt::Client::Coro> and L<DR::Tnt::Client::Sync>).
=item utf8
Default value is C<TRUE>. If C<TRUE>, driver will unpack all
lib/DR/Tnt.pm view on Meta::CPAN
=head1 CONNECTORS METHODS
All connectors have the same API. AnyEvent's connector has the last
argument - callback for results.
If C<raise_error> is C<false>, C<coro> and C<sync> drivers will
return C<undef> and store C<last_error>. Any successfuly call clears
C<last_error> attribute.
=over
Dancer-Plugin-DetectRobots
view release on metacpan or search on metacpan
lib/Dancer/Plugin/DetectRobots.pm view on Meta::CPAN
fetchrover
fido
finnish
fireball
fouineur
francoroute
freecrawl
funnelweb
gama
gazz
gcreep
Data-Frame
view release on metacpan or search on metacpan
data-raw/mpg.csv view on Meta::CPAN
"toyota","camry solara",2.4,2008,4,"manual(m5)","f",21,31,"r","compact"
"toyota","camry solara",2.4,2008,4,"auto(s5)","f",22,31,"r","compact"
"toyota","camry solara",3,1999,6,"auto(l4)","f",18,26,"r","compact"
"toyota","camry solara",3,1999,6,"manual(m5)","f",18,26,"r","compact"
"toyota","camry solara",3.3,2008,6,"auto(s5)","f",18,27,"r","compact"
"toyota","corolla",1.8,1999,4,"auto(l3)","f",24,30,"r","compact"
"toyota","corolla",1.8,1999,4,"auto(l4)","f",24,33,"r","compact"
"toyota","corolla",1.8,1999,4,"manual(m5)","f",26,35,"r","compact"
"toyota","corolla",1.8,2008,4,"manual(m5)","f",28,37,"r","compact"
"toyota","corolla",1.8,2008,4,"auto(l4)","f",26,35,"r","compact"
"toyota","land cruiser wagon 4wd",4.7,1999,8,"auto(l4)","4",11,15,"r","suv"
"toyota","land cruiser wagon 4wd",5.7,2008,8,"auto(s6)","4",13,18,"r","suv"
"toyota","toyota tacoma 4wd",2.7,1999,4,"manual(m5)","4",15,20,"r","pickup"
"toyota","toyota tacoma 4wd",2.7,1999,4,"auto(l4)","4",16,20,"r","pickup"
"toyota","toyota tacoma 4wd",2.7,2008,4,"manual(m5)","4",17,22,"r","pickup"
Data-MessagePack-Stream
view release on metacpan or search on metacpan
msgpack-3.3.0/example/x3/stream_unpack.cpp view on Meta::CPAN
//#define MSGPACK_USE_X3_PARSE
#include <msgpack.hpp>
#include <boost/asio.hpp>
#include <boost/coroutine2/all.hpp>
#if defined(__clang__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter"
#endif // defined(__clang__)
msgpack-3.3.0/example/x3/stream_unpack.cpp view on Meta::CPAN
#pragma GCC diagnostic pop
#endif // defined(__clang__)
namespace as = boost::asio;
namespace x3 = boost::spirit::x3;
namespace coro2 = boost::coroutines2;
using pull_type = coro2::asymmetric_coroutine<std::shared_ptr<std::vector<char>>>::pull_type;
// iterator fetching data from coroutine2.
class buffered_iterator : public std::iterator<std::input_iterator_tag, char> {
public:
using pointer_t = typename iterator::pointer;
using reference_t = typename iterator::reference;
msgpack-3.3.0/example/x3/stream_unpack.cpp view on Meta::CPAN
session(as::ip::tcp::socket socket)
: socket_(std::move(socket)) {
}
void start() {
sink_ = std::make_shared<coro2::asymmetric_coroutine<std::shared_ptr<std::vector<char>>>::push_type>(
[&, this](pull_type& source) {
// *1 is started when the first sink is called.
std::cout << "session started" << std::endl;
do_read();
source();
// use buffered_iterator here
// b is incremented in msgpack::unpack() and fetch data from sink
// via coroutine2 mechanism
auto b = boost::spirit::make_default_multi_pass(buffered_iterator(source));
auto e = boost::spirit::make_default_multi_pass(buffered_iterator());
// This is usually an infinity look, but for test, loop is finished when
// two message pack data is processed.
msgpack-3.3.0/example/x3/stream_unpack.cpp view on Meta::CPAN
);
}
as::ip::tcp::socket socket_;
static constexpr std::size_t const max_length = 1024;
std::shared_ptr<coro2::asymmetric_coroutine<std::shared_ptr<std::vector<char>>>::push_type> sink_;
};
class server {
public:
server(
Data-Monad-CondVar
view release on metacpan or search on metacpan
eg/bench_cv.pl view on Meta::CPAN
pick \my $y => sub { $cv2 };
yield {$x * $y};
}->recv;
}
sub coro($$) {
my ($cv1, $cv2) = @_;
async {
my $x = $cv1->recv;
my $y = $cv2->recv;
$x * $y;
eg/bench_cv.pl view on Meta::CPAN
my $r = Benchmark::timethese($count => {
bare_ae => sub { bare_ae(cv 5, cv 4) },
monad_for => sub { monad_for(cv 5, cv 4) },
monad => sub { monad(cv 5, cv 4) },
monad_lift=> sub { monad_lift(cv 5, cv 4)},
coro => sub { coro(cv 5, cv 4) },
});
for my $v (values %$r) {
$v->[1] = $v->[3] = $v->[0];
$v->[2] = $v->[4] = 0;
}
Benchmark::cmpthese($r);
__END__
% perl -Ilib eg/bench_cv.pl .0001 10000
Benchmark: timing 10000 iterations of bare_ae, coro, monad, monad_for, monad_lift...
bare_ae: 1.16068 wallclock secs ( 0.72 usr + 0.06 sys = 0.78 CPU) @ 12820.51/s (n=10000)
coro: 1.16513 wallclock secs ( 0.72 usr + 0.06 sys = 0.78 CPU) @ 12820.51/s (n=10000)
monad: 1.10253 wallclock secs ( 0.87 usr + 0.05 sys = 0.92 CPU) @ 10869.57/s (n=10000)
monad_for: 1.21874 wallclock secs ( 1.18 usr + 0.03 sys = 1.21 CPU) @ 8264.46/s (n=10000)
monad_lift: 1.33561 wallclock secs ( 1.30 usr + 0.03 sys = 1.33 CPU) @ 7518.80/s (n=10000)
Rate monad_lift monad_for coro bare_ae monad
monad_lift 3744/s -- -9% -13% -13% -17%
monad_for 4103/s 10% -- -4% -5% -10%
coro 4291/s 15% 5% -- -0% -5%
bare_ae 4308/s 15% 5% 0% -- -5%
monad 4535/s 21% 11% 6% 5% --
% perl -Ilib eg/bench_cv.pl 0 20000
Benchmark: timing 20000 iterations of bare_ae, coro, monad, monad_for, monad_lift...
bare_ae: 0.991276 wallclock secs ( 0.94 usr + 0.04 sys = 0.98 CPU) @ 20408.16/s (n=20000)
coro: 1.01837 wallclock secs ( 0.97 usr + 0.05 sys = 1.02 CPU) @ 19607.84/s (n=20000)
monad: 1.7295 wallclock secs ( 1.68 usr + 0.04 sys = 1.72 CPU) @ 11627.91/s (n=20000)
monad_for: 2.51117 wallclock secs ( 2.44 usr + 0.06 sys = 2.50 CPU) @ 8000.00/s (n=20000)
monad_lift: 2.69432 wallclock secs ( 2.63 usr + 0.07 sys = 2.70 CPU) @ 7407.41/s (n=20000)
Rate monad_lift monad_for monad coro bare_ae
monad_lift 3712/s -- -7% -36% -62% -63%
monad_for 3982/s 7% -- -31% -59% -61%
monad 5782/s 56% 45% -- -41% -43%
coro 9820/s 165% 147% 70% -- -3%
bare_ae 10088/s 172% 153% 74% 3% --
Data-Password-Filter
view release on metacpan or search on metacpan
share/dictionary.txt view on Meta::CPAN
cornstarch's
cornucopia
cornucopia's
cornucopias
corny
corolla
corolla's
corollaries
corollary
corollary's
corollas
corona
corona's
coronae
coronaries
coronary
coronas
coronation
coronation's
coronations
coroner
coroner's
coroners
coronet
coronet's
coronets
corpora
corpora's
corporal
corporals
corporas
share/dictionary.txt view on Meta::CPAN
decorations
decorative
decorator
decorator's
decorators
decorous
decorously
decors
decorum
decorum's
decoy
decoy's
share/dictionary.txt view on Meta::CPAN
indecision's
indecisive
indecisively
indecisiveness
indecisiveness's
indecorous
indeed
indeeds
indefatigable
indefatigably
indefensible
share/dictionary.txt view on Meta::CPAN
ranches
ranching
rancid
rancidity
rancidity's
rancorous
rancorously
rancour
rancour's
randier
randiest
random
Data-Password-Top10000
view release on metacpan or search on metacpan
lib/Data/Password/Top10000.pm view on Meta::CPAN
prelude
newton
lolita
ladies
hawkeye
corona
bubble
31415926
trigger
spike
katie
lib/Data/Password/Top10000.pm view on Meta::CPAN
dynamite
dupont
dogcat
dogboy
diane
corolla
citadel
buttfuck
bulldog1
broker
brittney
Data-Password-zxcvbn-French
view release on metacpan or search on metacpan
lib/Data/Password/zxcvbn/RankedDictionaries/French.pm view on Meta::CPAN
'cornillon' => 7158,
'cornu' => 487,
'cornuault' => 9519,
'cornuel' => 12883,
'cornut' => 6194,
'coron' => 9338,
'corona' => 7229,
'corpet' => 10618,
'corral' => 10065,
'corre' => 948,
'correia' => 200,
'corroyer' => 8462,
lib/Data/Password/zxcvbn/RankedDictionaries/French.pm view on Meta::CPAN
'corniche' => 6360,
'corniches' => 17752,
'cornouaille' => 24179,
'cornouailles' => 22488,
'cornwall' => 26207,
'corollaire' => 19289,
'corolle' => 16980,
'coronavirus' => 18963,
'corporate' => 26991,
'corporation' => 4812,
'corporations' => 11962,
'corporel' => 15492,
'corporelle' => 10420,
Data-Password-zxcvbn-German
view release on metacpan or search on metacpan
lib/Data/Password/zxcvbn/RankedDictionaries/German.pm view on Meta::CPAN
'convention' => 18516,
'conway' => 17895,
'cordoba' => 16739,
'corner' => 22161,
'cornwall' => 23819,
'corona' => 21675,
'corporate' => 14925,
'corporation' => 5276,
'corps' => 4592,
'corpus' => 15140,
'cortes' => 17896,
Data-Password-zxcvbn
view release on metacpan or search on metacpan
lib/Data/Password/zxcvbn/RankedDictionaries/Common.pm view on Meta::CPAN
'cornell' => 12931,
'corner' => 20897,
'cornflakes' => 22507,
'cornholio' => 20830,
'cornwall' => 7919,
'corolla' => 7767,
'corona' => 3036,
'corona1' => 23173,
'coronado' => 19891,
'corpse' => 28912,
'corrado' => 6116,
'corrie' => 18180,
'corsair' => 14247,
'corsica' => 6872,
lib/Data/Password/zxcvbn/RankedDictionaries/Common.pm view on Meta::CPAN
'varsity' => 18972,
'varvara' => 15040,
'vasant' => 16775,
'vasantha' => 26083,
'vasco' => 20539,
'vascorossi' => 26330,
'vaseline' => 19362,
'vasile' => 15652,
'vasilisa' => 13538,
'vasquez' => 17791,
'vasser' => 28117,
( run in 0.643 second using v1.01-cache-2.11-cpan-39bf76dae61 )