DASMx
Version 1.40, 18th October 2003
A microprocessor opcode disassembler
© Copyright 1996-2003 Conquest Consultants
DASMx and all associated documentation are copyright Conquest Consultants.
DASMx comes without any express or implied warranty. You use this software at your own risk. Conquest Consultants have no obligation to support or upgrade this software. Conquest Consultants cannot be held responsible for any act of copyright infringement or other violation of applicable law that results from use of this disassembler software.
DASMx is a disassembler for a range of common microprocessors. The following main processor families are supported:
q Motorola 6800 family and single chip variants (including Hitachi 630X devices);
q Motorola 6809;
q MOS Technology 6502 and Rockwell 65C0X;
q Zilog Z80;
q Sharp LR35902 (single chip Z80 variant as used in the Nintendo GameBoy);
q Intel MCS-80/85TM family (i.e. 8080 and 8085);
q Intel MCS-48TM family (i.e. 8048 et al);
q Intel MCS-51TM family (i.e. 8051 et al);
q Microchip PIC16CXX family;
q RCA CDP1802 COSMAC and variants;
q Signetics 2650.
The disassembler takes as input a binary code/data image file (typically a ROM image) and generates either an assembler source file or a listing file. DASMx is a multi-pass disassembler with automatic symbol generation. DASMx can optionally use a symbol file containing user-defined symbols and specifications of data areas within the source image.
DASMx includes a powerful feature called code threading. Using known code entry points (e.g. reset and interrupt vectors) and by performing partial emulation of the processor, the disassembler is able to follow known code paths within a source binary image.
Use of code threading, together with the multi-pass operation and symbol table management permits readable assembly code output from source images that contain large amounts of data (which tend to confuse most disassemblers).
DASMx is copyright software. This version (1.40) may be distributed and used freely provided that all files are included in the distribution, no files are modified (including the distribution zip file) and no charge is made beyond that reasonable to cover copying (maximum $10 US).
Historical note: Version 1.10 of DASMx superseded the Motorola 680x disassembler, dasm6800 (last released as version 1.00 on 25th January 1997). The change of name reflected the wide range of processors then covered.
The key features of DASMx are:
q Disassembly of object code images for the following microprocessors:
· Motorola 6800, 6802 and 6808;
· Motorola 6801 and 6803;
· Hitachi 6301 and 6303;
· Motorola 6805;
· Motorola 68HC05
· Hitachi 6305;
· Hitachi 63L05;
· Motorola 6809;
· MOS Technology/Rockwell 6502;
· Rockwell 65C00/21 and 65C29;
· Rockwell 65C02, 65C102 and 65C112;
· Intel 8048;
· Intel 8051;
· Intel 8080 and 8085;
· Microchip PIC16F83 and PIC16F84;
· RCA CDP1802 COSMAC;
· RCA CDP1805 and CDP1806;
· Sharp LR35902 (i.e. GameBoy processor);
· Signetics 2650;
· Zilog Z80 and National Semiconductor NSC800.
q Multi-pass operation, with automatic symbol generation for jump, call and data target addresses;
q Code threading (used to automatically differentiate code from data);
q Control file containing user defined symbols, specifications of data areas and code entry points;
q Generation of full listing or assembler output file;
q Runs from the Windows command line.
|
Version |
Date |
Comments |
|
0.90 |
28th July 1996 |
First public release (as dasm6800): with support for 6800/6802/6808 only. |
|
1.00 |
25th January 1997 |
Second release (as dasm6800): 6801/6803 and 6809 support added; other improvements in performance and listing output. |
|
1.10 |
16th July 1997 |
Third release (now renamed DASMx): 6502, Z80 and 8048 processor support added; minor improvements and bug fixes. |
|
1.20 |
2nd April 1998 |
8080, 8085 and 2650 processor support added; improvements and bug fixes. |
|
1.30 |
6th October 1999 |
6301, 6303, 65C00/21, 65C29, 65C02, 65C102, 65C112, 8051 and LR35902 processor support added; wide listing format showing execution cycles; checksum and CRC-32 calculation; number format improvements; new symbol file directives; other improvements and bug fixes. |
|
1.40 |
18th October 2003 |
6805, 68HC05, 63L05, 6305, NSC800, CDP1802, CDP1805/1806, PIC16F83 and PIC16F84 processor support added; new checksum utility; bug fixes and improvements. |
The changes from version 1.30 are:
q Disassembly of 6805, 68HC05, 63L05 and 6305 added;
q NSC800 CPU type added (identical instruction set to Z80);
q Disassembly of RCA CDP1802 COSMAC and CDP1805/1806 added;
q Disassembly of Microchip PIC16F83 and PIC16F84 added;
q New DWORD data type in symbol file;
q Symbol file code directive changed to allow length parameter;
q Checksum command line utility added to distribution;
q Origin now defaults to 0;
q RCA and Acorn ARM number formats added;
q Bug fixes and improvements to: 2650, 6502, 6809, 8051, & GameBoy;
q Bug fix: Signetics number type now allowed in symbol file;
q Improvements to code/data differentiation algorithm affecting disassembly for all processors.
The changes between versions 1.20 and 1.30 were:
q Disassembly of Hitachi 6301 and 6303 added;
q Disassembly of Rockwell 65C00/21, 65C29, 65C02, 65C102 and 65C112 added;
q Disassembly of Intel 8051 added;
q Disassembly of Sharp LR35902 (GameBoy processor) added;
q Corrected documentation concerning Hitachi 6309 (which has, in fact, an identical instruction set to the 6809);
q Labelling and threading improvements for 8080, 8085 and Z80 disassembly (affects RST and indirect addressing instructions);
q Correction to instruction format for 2650 lodz/eorz/andz/…;
q New wide listing format showing execution cycles for each instruction;
q File size, checksum and CCITT CRC-32 calculated and shown in listing header;
q Auto number format determined by processor type (which can be overriden by a directive in the symbol file);
q User messages can now be specified and generated from the symbol file;
q Symbol file includes (which may be nested) now permitted.
The changes between versions 1.10 and 1.20 were:
q Disassembly of Intel 8080 and 8085 added (in addition to existing support for 8080 provided by Z80 disassembly);
q Disassembly of Signetics 2650 added;
q New symbol file command to skip areas of source image;
q Origin can now be specified in symbol file;
q New command line option to specify a single code entry point for threading;
q New command line option to list all processors supported;
q Fix to incorrect disassembly of 6801/6803 subd instruction (opcode 0x93);
q Bug fixes and other minor changes.
The changes between versions 1.00 and 1.10 were:
q All references to “dasm6800” replaced by “DASMx”;
q Disassembly of 6502 added;
q Disassembly of Z80 added;
q Disassembly of 8048 added;
q Minor bug fix for code threading of 6801/6803 direct branch instructions;
q Minor changes to listing output;
q Bug fixes and other minor improvements.
The changes between versions 0.90 and 1.00 were:
q Disassembly of 6801/6803 added;
q Disassembly of 6809 added;
q Define byte pseudo-op now generates full listing;
q Two new commands supported in symbol file: cpu (to select processor type) and addrtab (to define a table of addresses, each of which points to data);
q New command line switch to select processor type;
q Performance improvement to pass 1;
q Minor changes to listing output;
q Bug fixes and other minor improvements.
DASMx is copyright software. This version (1.40) may be distributed and used freely provided that all files are included in the distribution, no files (including the distribution zip file) are modified and no charge is made beyond that reasonable to cover copying (maximum $10 US). Conquest Consultants reserve the right to alter the free distribution and use terms for any future versions or derivatives of DASMx that may be produced.
DASMx version 1.40 is distributed as file dasmx140.zip in the WinME / Win98 / Win95 / Programming Utilities section of the Simtel.net archive. Provided that the above distribution terms are adhered to, this file may be freely copied to and mirrored at other ftp and web sites.
Before describing the operation of DASMx in detail, here is an overview of how the disassembler will be typically used in practice.
First, you must obtain a file containing a binary image of the code/data that you wish to disassemble. Typically, this will be from one or more ROMs or EPROMs that have been read using a PROM programmer. Some PROM programmers output data in a form of ASCII hexadecimal format (Intel and Motorola are two common formats). If that is the case, then you must use a conversion utility to generate a raw binary image. A good check that you have a correct binary image of a complete ROM is that the file length (shown by a DIR command) will be a power of two and will correspond to the length of the ROM. For example, the file size of a complete image of a 27256 EPROM will be 32,768 bytes.
Assuming at this stage that you do not know which areas of the binary image are code and which are data, it is sensible to use the code threading feature. For code threading to work, you must provide at least one code entry point. This requires code, vector or vectab entries in a symbol file. For example, if you are disassembling a ROM image from the uppermost region of the 6800 microprocessor address space, then four vector entries for the standard interrupt and reset vectors will be all that is initially required to provide the necessary entry points. You can also improve the readability of the disassembled output by defining symbols for all known hardware addresses (e.g. PIA registers and other ports).
Try modifying one of the supplied example symbol files to suit your application. It is important that the correct processor type is specified using a cpu directive in the symbol file (or by command line switch). The disassembler will not make much sense of Z80 code if it thinks that the processor is a 6502!
Run the disassembler with code threading. This will identify all known areas of code. Data and unknown areas will be listed as byte data rather than disassembled into instruction mnemonics. Due to limitations of the code threading process (see below) not all code areas may be identified. Any additional code entry points or address vector tables can be added to the symbol file. Similarly, areas of byte, word or string data that can be identified from examination of the disassembly listing can also be recorded in the symbol file.
Using a repeated “disassemble, inspect listing, update symbol file” cycle a comprehensive disassembly of an image can be built up quite quickly.
Finally, if you are satisfied that you have identified all main data areas, try disassembling without code threading. This will help pick up areas of code that may have been missed by the code threading and subsequent manual investigation process.
DASMx is a Win32 console application. This means that it is a 32-bit application that requires Windows 95/98/Me or Windows NT/2000/XP to run. Typically, you will run the disassembler from a command line window.
DASMx has the following command line options:
|
-a |
Generate assembler output (default is to generate a full listing file). |
|
-cTYPE |
Set the CPU processor type – overrides any cpu statement in the symbol file, where TYPE is one of the types reported by the -l option (6800, 6809, 6502, Z80 etc.) (default is 6800). |
|
-eNNNN |
Specify a code entry point NNNN for threading. |
|
-l |
List all processors supported and exit. |
|
-oNNNN |
Set the origin, or start address to NNNN (default is top of address space less the length of the source image). |
|
-t |
Perform code threading (requires at least one code entry point to be specified). |
|
-v |
Display version information and exit. |
|
-w |
Wide listing format (shows instruction cycles and up to 8 data bytes per line). |
When specifying addresses, the number NNNN should be specified using C language conventions (i.e. default is decimal, prefix with 0x for hex, prefix with 0 for octal).
The primary input file is a binary image of the code/data to be disassembled. This must be code for one of the supported microprocessors (or other manufacturer equivalent). DASMx will produce meaningless output for any other type of processor.
DASMx assumes a file extension of “.bin” unless otherwise specified for the binary image file.
DASMx looks for a symbol file of the same base name as the source binary file, but with a “.sym” file extension. If a symbol file is found, it will be used. Provision of a symbol file is optional, except where code threading is used (where a symbol file must be used to define at least one code entry point).
The symbol file is a plain text file that may be created/modified with any text editor. The file contains lines that fall into one of three categories:
q Comment lines;
q Command lines;
q Blank lines.
Comment lines are denoted by ‘;’ as the first non-whitespace character on the line. Command lines start with one of the specified keywords. Parameters follow the command keyword, separated by spaces or tabs. A comment may be added to the end of a command, preceded by the ‘;’ character. Blank lines are ignored.
Number value parameters may be given in decimal (the default), octal or hex using standard C language conventions (e.g. 0x prefix for hex).
The symbol file command syntax contains an include directive which allows one symbol file to be included within another. Included files may be nested to any practical depth. A particular use of this feature is to have a symbol file containing a generic set of defintions for a processor or item of hardware. This can then be included within a symbol file with additional definitions for a specific software image that runs on that processor/hardware. The pair of example files, gameboy.sym and tetris.sym, shows this in action with generic GameBoy definitions in one file and specific defintions for a tetris game cartidge in the other.
Valid command keywords and their meaning are summarised in the table below.
|
Command |
Function/syntax |
|
cpu |
Specify the processor type. |
|
numformat |
Specify number format (overriding default for
processor) as ARM, Intel, Motorola, RCA, Signetics, C language hex (i.e. 0x prefix)
or decimal. |
|
include |
Include a file containing additional symbol
commands. Include filess may be
nested. |
|
message |
Generate a message to the console during
disassembly. |
|
org |
Define the start address for the first byte of the
code/data image. Note that only one
org statement should be present in a symbol file. |
|
symbol |
Define a symbol corresponding to a value (usually an
address). |
|
vector |
Define a location that contains a word pointing to a
code entry (for example, the reset entry point). |
|
vectab |
Define a table of vectors (i.e. a jump table) of
length <count>. Each vector will be used as a code entry
point if threading is used. |
|
code |
Define a code entry point (for code threading). Optionally, <count> may specify the length of the code region in
instruction words. |
|
byte |
Define a single data byte, or <count> length array of bytes. |
|
word |
Define a single data word, or <count> length array of words. |
|
addrtab |
Define a table of addresses, which point to data, of
length <count>. |
|
string |
Define a single data character, or <count> length string of chars. |
|
skip |
Skip (i.e. omit from disassembly and listing) <count> length data bytes. |
By default, DASMx generates a disassembly listing file. This is similar to the full listing file generated by most assemblers. Optionally, DASMx can be made to produce an assembly file instead. This could then be used as a source file to an assembler of your choice (with certain provisos concerning pseudo-ops and number formats noted later).
As an aid to readability, DASMx inserts a comment line after all breaks in a sequence of instructions (e.g. after an unconditional branch or jump, or a return from subroutine). Comment lines are also inserted between code and data areas. This use of comment lines breaks the output listing into identifiable sections and aids manual inspection of the resultant disassembly listing.
Note that output files tend to be large. For example, a 32 Kbyte ROM image will generate a listing file of around half a megabyte in length.
The output file is named based upon the name of the source image file, but with a file extension of “.lst” for the list file or “.asm” for the assembly output file.
The list file format is largely self-explanatory. Program counter and code/data byte values are given in hex. Code/data is also shown as ASCII characters (where printable) as an aid to identifying strings within the binary image. If the wide listing format is selected then instruction cycle counts are also given for every instruction.
Instruction cycles are shown within [square braces]. If an instruction takes a variable number of cycles to execute (e.g. a conditional branch on many processors) then two values are shown: the minimum and the maximum.
Code threading is a very powerful feature that will automatically identify known areas of code. It can prove particularly useful in the early stages of disassembly of an image that contains large areas of data. Such data areas would otherwise be disassembled incorrectly as code and would add many erroneous symbols to the symbol table.
Code threading works by performing a partial emulation of the processor; executing instructions starting from one or more known entry points. Code threading follows calls to subroutines and conditional and unconditional branches. In certain cases, the code threading may fail to follow certain code paths (i.e. leaving valid code still defined as data). The following are examples of where the code threader will fail to follow a correct execution path:
q Pushing an address onto the stack and then, later, performing a return from subroutine instruction (i.e. as a method of performing a jump);
q Performing an indexed branch instruction (e.g. using addresses taken from a vector table);
q Use of undocumented instruction opcodes – since threads are abandoned when an invalid opcode is detected;
q Self-modifying code.
Indexed branch instructions are highlighted in the output listing by automatically generated comments. These are an indication that you need to manually identify what the contents of the index register will be prior to the branch (often obvious – look for a preceding load index register instruction.) Then, you can add a code or a vectab entry to the symbol file and repeat the disassembly.
In rare cases, code threading may incorrectly identify data as code:
q A call to a subroutine that never returns (e.g. the subroutine discards the return address); the other side of the call containing data rather than code.
q A conditional branch that is always, or never, executed (and the other side of the branch contains data rather than code).
Normally this latter scenario is pretty unlikely and requires a particularly perverse programmer of the original code. However, it is a technique that may be encountered on those processors that have a “better” (i.e. fewer cycles and/or fewer bytes) conditional jump than unconditional jump. So, in general, code threading will identify guaranteed known areas of code that may be a subset of the overall actual code. Most of the above problem areas can be dealt with by manual inspection of the disassembly listing and subsequent additions to the symbol file.
A thread of execution will be abandoned for one of two reasons. If a branch or subroutine call is made outside the address range corresponding to the source image then that thread is not followed. Also, if an invalid instruction is detected then the thread terminates immediately. This will produce a command line error message identifying the address where the problem occurred. Normally this represents an error condition that can be corrected by the person operating the disassembler:
q The processor type is incorrectly specified;
q The source binary image is not real code;
q An incorrect code entry point has been supplied;
q So called “undocumented” instructions have been used.
In rare cases, the original programmer may have done something that causes the code threader to incorrectly identify data as code. These cases may also result in invalid instruction messages.
The following sub-sections detail items of note relating to disassembly for the specific microprocessors (and their variants) supported by DASMx.
The Motorola 6800, 6802 and 6808 share an identical instruction set.
Assembler mnemonics follow the Motorola standard definitions (see reference [1]). Note that there are two common styles for instructions that involve the A and B registers:
q The A or B register name is separated by whitespace from the base instruction (e.g. lda b value);
q The A or B register name is used as a suffix to the instruction mnemonic (e.g. ldab value).
DASMx uses the latter style. This point also applies to the 6801/6803 and 6809 mnemonics generated by the disassembler.
The Motorola 6801 and 6803 share an identical instruction set that is an object code compatible superset of that of the base 6800. These processors contain on-chip timer and I/O plus an expanded interrupt vector area over that of the 6800. Definitions for these in a symbol file will be useful for disassembly of any 6801/6803 code. See the supplied 6803 symbol file, ebcgame.sym, for an example that could be used as a template for other 6801/6803 disassembly.
The Hitachi 6301 and 6303 are enhanced versions of the Motorola 6801/6803 with an enhanced object code compatible instruction set. Differences include a few additional instructions and pipelining that improves some instruction times.
The 6805 is another single chip microprocessor from Motorola. But, unlike the 6801/6803 it has an instruction set that no longer object code compatible with the original 6800. Mostly found in embedded applications, the 6805 formed the starting point for a series of microprocessors from Motorola and Hitachi.
The Hitachi 63L05 has an identical instruction set to the Motorola 6805, but with different cycle counts for some instructions.
The Motorola 68HC05 and 68HC705 have an instruction set that is a superset of the Motorola 6805. It has three extra instructions: stop, wait and mul. There are also cycle count differences from the base 6805.
The Hitachi 6305 has an instruction set that is a superset of the Motorola 6805. It has three extra instructions: stop, wait and daa. There are also cycle count differences from the base 6805.
The Motorola 6809 has an instruction set that is compatible with that of the 6800 at the assembler level (i.e. it is not binary compatible, but every 6800 instruction mnemonic is present in the 6809 instruction set). The 6809 also has many additional instructions that are not present in the 6800.
Note:the Hitachi 6309 was incorrectly included in earlier
versions of DASMx as having an identical instruction set to the
6809. This mistake was due to incorrect
information in a Hitachi data book. It
is now understood that the 6309 has a greatly expanded set of instructions over
the 6809. Full support for the 6309 may
be added in a future version of DASMx.
The MOS Technology/Rockwell 6502 has a similar instruction set to that of the 6800 (but totally opcode incompatible).
A number of 6502 variants, with expanded instruction sets and addressing capabilities have appeared over the years. DASMx copes with some, but not all, of these variants (see next sections). If you know that a processor is based on the 6502 architecture, but are unsure of the variant then try disassembling with the CPU type set to 6502, 65C02 and 65C00. Inspect the results and select whichever gives the most intelligent disassembly. [Tip: try this with code threading and select the processor that gives least threading errors.]
The Rockwell 65C00/21 and 65C29 each contain two enhanced CMOS 6502 CPU cores plus on-chip masked ROM, RAM, two timers and general purpose I/O. Instruction set differences over the basic NMOS 6502 include new instructions for unsigned multiply, memory bit set and reset, branch on bit set/reset, unconditional branch and push/pop for the index registers. With the exception of the multiply instruction, these new instructions are a subset of the additional instructions in the 65C02.
Note that the CPU type for the 65C00/21 should be specified as 65C00 (i.e. without the trailing “/21”).
The Rockwell 65C02 is an improved version of, and object code compatible with, the original NMOS 6502 with twelve new basic instructions (giving 59 new opcodes with variants). The 65C02 is pin compatible with the original 6502. The 65C102 is similar, but with minor pinout differences to provide for multi-processor bus operation. The 65C112 has no internal clock oscillator and is designed as a slave processor to the 65C102. The extra instructions include all of the additions found in the 65C00/21 and 65C29 dual processors – with the exception of the multiply instruction found in those devices.
The Zilog Z80 (also made by Mostek, Sharp, NEC and other second sources) has an instruction set that is binary compatible with that of the Intel 8080, but with many additional instructions. Although each 8080 instruction has an identical Z80 instruction, Zilog chose to use a different mnemonic style for almost every instruction. Consequently, Z80 assembler (even if restricted to the 8080 subset) appears quite different even though the resulting binary image is identical.
The Z80 has a great many (so called) undocumented instructions that (sometimes) perform useful functions. DASMx does not currently support these additional instructions.
Like the 6502, the Z80 has spawned many variants with opcode compatible instruction supersets. DASMx can be used on code for these devices with the standard caveat that any of the new instructions will not be disassembled as valid code (and therefore code threading is not advised.)
The National Semiconductor NSC800 has an identical instruction set to the Zilog Z80. The differences between a Z80 and the NSC800 were all electrical. The NSC800 was fabricated in a CMOS process called P2CMOS. It also had a bus architecture that was compatible with the Intel 8080 (i.e. multiplexed address and data bus) and was therefore not pin compatible with a standard Z80.
The Sharp LR35902 is the processor used in the hugely popular Nintendo GameBoy. This processor is a single chip variant of the Zilog Z80. The instruction set is based on a subset of that of the Z80 but with some additional instructions. Of those instructions that are shared with the Z80, most are opcode compatible but there are a few differences.
As a single chip microcontroller, the LR35902 contains various on-chip I/O and timer functions. These are accessed through a 256 byte memory page starting at address 0xFF00. The supplied file, gameboy.sym, contains a set of known symbol definitions for these memory mapped registers. This generic GameBoy processor symbol file may be included in the main symbol file for the disassembly of a specific binary image. The supplied tetris.sym file shows an example of this.
|
WARNING: unlike all the other processors supported by DASMx, it has not been possible to obtain official manufacturer's data on the Sharp LR35902. The information used is derived from a number of different public domain documents – some of which conflict over certain details. Consequently, the LR35902 disassembly should be considered provisional and potentially subject to error. If anyone has access to genuine Sharp (or other official) data on this device please contact the author<EMAIL_ADDRESS>|
The Intel 8080 and 8085 share an almost identical instruction set. The Intel 8085 is an enhanced version of the 8080, with two additional instructions (rim and sim) used to control new serial in and out pins and interrupt inputs.
When disassembling 8080 (and, with provisos, 8085) code the user has the option of generating either Intel or Zilog mnemonics. To generate Intel mnemonics, simply specify the CPU type to be 8080 or 8085 as required.
Generating Zilog Z80 style mnemonics from Intel 8080 code is possible because the 8080 has an instruction set that is a compatible binary subset of those of the Z80. Simply specify the CPU type is as Z80 and DASMx will correctly disassemble 8080 code into Zilog mnemonics. This will not suit Intel assembler die-hards, but may be preferred by those more familiar with the Z80.
WARNING: if DASMx is used as a Z80 disassembler on 8085 code and either of the two 8085 specific instructions are used (rim and sim) then problems will result. In such cases Zilog disassembly is probably best avoided. If you really must have Zilog mnemonics then read the following description of how these instructions are handled and be prepared for code threading to work incorrectly.
rim is a one byte instruction, but DASMx will attempt to disassemble this as the two byte jr nz Z80 instruction. This will both generate a false label and ignore the next byte in the 8085 opcode stream. Since that could be the first byte in a multi-byte opcode it could take a number of erroneously disassembled instructions before synchronisation is achieved.
sim is a one byte instruction that will be disassembled as the first byte of the three byte ld hl immediate instruction. The results will be similar to those for rim.
DASMx will disassemble opcodes for the following Intel MCS-48™ family devices (and equivalents from second source manufacturers): 8021, 8022, 8035, 8039, 8041, 8741, 8048, 8049 and 8748. The CPU type should be set to 8048 and the term "8048" is used throughout this documentation to refer to this family of devices.
The 8021 instruction set is a much reduced subset of the full 8048 set of instructions.
The 8022 has a very similar instruction set to the 8021, but with slightly more of the 8048 instructions and a few new instructions to handle the on-chip analogue to digital converter.
The 8041/8741 has almost the same instruction set as the 8048, but with just a few instructions missing.
DASMx can disassemble code for the 8021, 8022, 8041 and 8741 variants with the caveat that data areas may be disassembled as 8048 instructions that are in fact illegal on the variant.
The 8048 jump and call instructions operate on an 11-bit address (i.e. within a 2 Kbyte memory bank). A memory bank select bit (controlled by the sel mb0 and sel mb1 instructions) is combined with the 11-bit jump/call address to give full 12-bit addressing within the 4 Kbyte address space of the 8048. This presents a problem for the code threading and automatic label generation functions of DASMx since a destination address can only be fully calculated if the last memory bank select operation is known. Tracking the state of the memory bank select bit is currently beyond the capabilities of DASMx. For this reason, it is advised that code threading be not used if the size of the 8048 source image exceeds 2 Kbytes. If images greater than this are disassembled, even with threading disabled, some errors in automatically generated labels may be expected.
Intel introduced the 8051 to provide an upgrade path from the 8048. It would do all that the 8048 would do and more. The heritage of the 8048 is obvious in the architecture and instruction set of the 8051.
Like the 8048, the 8051 was initially available in a number of variants (e.g. 8031 and 8751). Subsequently, many further variants of the 8051 have been produced by Intel and by other manufacturers. Some of these added to the instruction set.
DASMx will only correctly disassemble code for the original 8051 devices that shared the MCS-51™ instruction set.
The Signetics 2650 is a rather oddball processor when compared to most other 8-bit processors handled by DASMx. It operates on 8-bit data and can address 32,768 bytes of memory organised in four pages of 8,192 bytes each. It has a large range of addressing modes, made possible by the use of bits encoded in the second byte of two and three byte instructions. It has a 3-bit stack pointer, which means that subroutines can be nested to, at most, eight deep.
The CDP1802 is a single chip implementation of the earlier CDP1801/CDP18101 two-chip pairing. Its main novelty at the time of launch was fabrication using CMOS technology (at a time when most microprocessors were being made using NMOS). Its internal register architecture is also a little bit different from most contemporary processors. It is well endowed with registers – sixteen 16-bit to be precise – any one of which can be designated the Program Counter and another the Stack Pointer. Unusually for processors of the era it also had rudimentary DMA capabilities.
With just one exception, every possible 8-bit instruction opcode is valid. This means that attempting to disassemble data will usually produce sequences of “code”.
Using the one invalid opcode in the CDP1802 instruction set as a prefix instruction allowed the instruction set of the CDP1805 and CDP1806 to be expanded over that of the similar CDP1802 COSMAC.
The Microchip PIC16F83 and PIC16F84 are both members of the Microchip PIC16CXX family of 8-bit microcontrollers. These devices include on-board flash memory for program storage. Other members of the family have ROM instead of flash memory. These are known as the PIC16CR83 and PIC16CR84. The processors are classified as “8-bit” due to the basic size of data transfers. However, program memory is organised in 14-bit words with each instruction occupying a single 14-bit word. DASMx assumes that the code image contains these 14-bit words, each aligned to a 16-bit boundary – each 16 bits of the code image containing the 14 actual bits with the top two bits set to zero. These 16 bit words are assumed to be in little endian format.
The PIC16F83 et al represent just a common example of processors in the PIC16CXX family. They have an expanded instruction set over the PIC16C5X, for example. Consequently, DASMx may be used to disassemble code intended for other PIC processors with some success. Future versions of DASMx may add explicit support for all these variants.
Assembler pseudo operations (e.g. that to define a data word) are not in a standard style that matches the chosen processor. The pseudo-ops are common across all processor disassembly output. In general, the pseudo-ops follow Intel conventions:
q The ‘;’ character to denote a comment;
q The ‘:’ character following a label;
q db, to define a data byte, character or string;
q dw, to define a data word;
q org, to specify a starting address.
If these do not suit your preferred assembler, then use of search and replace in a text editor can probably effect the required changes.
Microprocessor manufacturers have chosen a variety of different formats[1] for representing hexadecimal numbers.
DASMx supports seven different hex number format styles. These are summarised in the table below, with an example in each case for the hex number F12C.
|
Number format |
numformat parameter |
Example |
|
ARM |
A |
&F12C |
|
Intel |
I |
0F12CH |
|
Motorola |
M |
$F12C |
|
RCA |
R |
#F12C |
|
Signetics |
S |
H’F12C’ |
|
C language |
C |
0xF12C |
|
Decimal |
D |
61740 |
DASMx chooses a default number format according to the CPU type setting. A numformat statement in the symbol file can override the default choice. The number format defaults for the processors supported by DASMx are given in the following table.
|
Manufacturer |
cpu parameter |
Format |
|
Microchip |
PIC16F83 |
C language |
|
Microchip |
PIC16F84 |
C language |
|
RCA |
1802 |
RCA |
|
RCA |
1805 |
RCA |
|
Signetics |
2650 |
Signetics |
|
MOS Technology |
6502 |
Motorola |
|
Rockwell |
65C00 |
Motorola |
|
Rockwell |
65C02 |
Motorola |
|
Rockwell |
65C29 |
Motorola |
|
Rockwell |
65C102 |
Motorola |
|
Rockwell |
65C112 |
Motorola |
|
Hitachi |
6301 |
Motorola |
|
Hitachi |
6303 |
Motorola |
|
Hitachi |
6305 |
Motorola |
|
Hitachi |
63L05 |
Motorola |
|
Motorola |
6800 |
Motorola |
|
Motorola |
6801 |
Motorola |
|
Motorola |
6802 |
Motorola |
|
Motorola |
6803 |
Motorola |
|
Motorola |
6805 |
Motorola |
|
Motorola |
68HC05 |
Motorola |
|
Motorola |
6808 |
Motorola |
|
Motorola |
6809 |
Motorola |
|
Intel |
8048 |
Intel |
|
Intel |
8051 |
Intel |
|
Intel |
8080 |
Intel |
|
Intel |
8085 |
Intel |
|
Zilog |
Z80 |
Intel |
|
Sharp |
LR35902 |
Intel |
The number formatting applies to all operands in disassembled instructions with the exception of small positive or negative offsets in 6809 index instructions. These are given as a signed decimal number.
Whilst there is no guarantee that future versions of this disassembler software will be released, some or all of the following areas are likely to receive attention in any future version:
q Fixing any errors discovered in the instruction mnemonics or disassembly of an opcode to its instruction;
q Rationalisation of the pseudo-ops such that the assembler output can be fed directly into at least one common assembler without further text editing;
q Improved code threading (through use of a more complete emulation of the processor);
q Improved symbol table output in listing file;
q Specifying comments in the symbol file for inclusion in the output files;
q Additional memory map output in listing file;
q Better support for 8048 code greater than 2 Kbytes and for 8048 variants;
q Support for additional microprocessors;
q Support for further variants of the currently supported processors;
q Disassembly of commonly known “undocumented” instructions.
Fixing actual disassembly errors (if any are discovered) will be treated with priority.
Note that it is not currently intended to support platforms other than Windows 95/98/Me or Windows NT/2000/XP. In particular, there will be no 16-bit versions for DOS or any other 16-bit operating systems. If the demand exists, a Linux version may be produced.
Feedback to Conquest Consultants may be made via<EMAIL_ADDRESS>The following publications were referred to in the course of the development of DASMx. This may also be considered to be a useful reference list for anyone programming these processors at assembler level and/or inspecting the output of DASMx.
|
[1] |
M6800 Microprocessor Applications Manual, Motorola Semiconductor Products Inc., First Edition, 1975. |
|
[2] |
Hitachi Microcomputer Databook 8-bit HD6800 & 16-bit HD68000, Hitachi Ltd., March 1983. |
|
[3] |
Programming the 6502, Rodnay Zaks, Sybex,
ISBN 0-89588-046-6, Third Edition, 1980. |
|
[4] |
6502 Assembly Language Programming, Lance A.Leventhal,
Osborne/McGraw-Hill, ISBN 0-931988-27-6, 1979. |
|
[5] |
6502 Assembly Language Programming, Second Edition, Lance
A.Leventhal, Osborne/McGraw-Hill, ISBN 0-07-881216-X, 1986. |
|
[6] |
R650X and R651X Microprocessors (CPU), Rockwell, 29000D39, Data Sheet
D39, Revision 6, February 1984. |
|
[7] |
MCS6500 Microcomputer Family Programming Manual, MOS Technology Inc., Second Edition, Publication Number 6500-50A, January 1976. |
|
[8] |
1984 Data Book, Semiconductor Products Division, Rockwell
International, March 1984. |
|
[9] |
TLCS-Z80 System Manual, Toshiba, 4419 '84-05(CK), June 1984. |
|
[10] |
Microcomputer Components Databook, Mostek, MK79778, July 1979. |
|
[11] |
Z80-Assembly Language Programming Manual, Zilog, 03-0002-01, Rev
B, April 1980. |
|
[12] |
The MCS-80/85 Family User's Manual, Intel, ISBN 1-55512-009-1, 1986. |
|
[13] |
MCS-48TM User's Manual, Intel, 9800270D, July 1978. |
|
[14] |
48-Series Microprocessors Handbook, National Semiconductor, 1980. |
|
[15] |
Component Data Catalog, Intel, 1980. |
|
[16] |
An Introduction to Microcomputers: Volume 1, Basic Concepts,
Second Edition, Adam Osborne, Osborne/McGraw-Hill, ISBN 0-931988-34-9,
1980. |
|
[17] |
Osborne 4 & 8-Bit Microprocessor Handbook, Adam Osborne &
Gerry Kane, Osborne/McGraw-Hill, ISBN 0-931988-42-X, 1980. |
|
[18] |
2650A/2650A-1 Data Sheet, Signetics. |
[1] Some sort of formatting is essential; otherwise a hex number starting with an alpha character could be confused with a label or symbol name.


pushed
{{ event.payload.distinct_size }} commits to
{{ event.payload.action }}
{{ event.payload.action }}
{{ event.payload.action }} watching
created {{ event.payload.ref_type }}
{{ event.payload.ref }}
deleted {{ event.payload.ref_type }} {{ event.payload.ref }}


--- title: Welcome description: Fimero Open Source Software --- MFE Quant Open Source Financial Engineering


fun requireCompatActivity(): AppCompatActivity
Return the AppCompatActivity this fragment is currently associated with.
IllegalStateException
- if not currently associated with an activity or if associated
only with a context.
TypeCastException
- if the currently associated activity don't extend AppCompatActivity.
See Also


Fail-open login mechanism
- Perform valid login and record all inputs to the web app
- Login again and modify inputs
- a. Submit an empty string as the value.
- b. Remove the name/value pair altogether.
- c. Submit very long and very short values.
- d. Submit strings instead of numbers and vice versa.
- e. Submit the same item multiple times, with the same and different values.
- Review responses with comparer
- Combine inputs which changed response and web app behaviour
- If there is multistep login note all input params and cross-request them in different stages
Insecure Storage of Credentials
- Is password in server responses?
- If we can retrieve passwords
- check for non-unique hashes (common passwords or non-salted passwords)
- query online rainbow tables for unsalted hashes
Weak lock-out mechanism
- Try incorrectly login 3x. Can you log in with correct credentials on 4th trial?
- Try incorrectly login 4x. Can you log in with correct credentials on 5th trial? ...
- Determine how many incorrect inputs needed to lockout.
- Attempt to login 5 min later, 10 min later ...
- Determine when is account unlocked
- Test unlock mechanism (unlock URL, security questions)


Pat's Salmoon Cokiees: Sales Data:
- Home
Welcome to my form
Location Name
Minimum number of customer
Miximum number of customer
Avarege number of coockies Sale


The depth index is a simple additive index of 7 key statements that can be part of a PTA.
The 7 key statements are tariff reduction, intellectual property rights protection, government purchases, technical barriers to trade, services, investments and compe-tition. The scale of the index is 0 – 7. The depth measure used here was developed by
Dür, Baccini, and Elsig (2014).
The depth of PTAs is heterogeneous. Some PTAs cover a large number of different issues, from trade in services to government purchases, whereas others are very narrow. Some PTAs include far-reaching statements, while others are relatively shallow.
For example, a PTA with a depth score of 0 is an agreement with no substantive statements in any of the 7 key statements. On the other extreme, a PTA with a depth score of 7 is more than an agreement with substantive statements in all 7 key statements.
Further details on the index are provided in
Table 1.
Note that the depth index is not available (N.A.) for all PTAs because the researchers did not find full texts for all agreements.


Modelul Osi
Tofu portland man braid, cliche YOLO tumeric taxidermy. Ethical cliche vice lumbersexual, whatever flexitarian tacos farm-to-table butcher humblebrag irony celiac truffaut tattooed.
Everyday carry fixie shoreditch gastropub, salvia hot chicken photo booth 3 wolf moon chambray woke tattooed blue bottle raw denim art party. Raclette poutine ugh, glossier beard echo park crucifix coloring book slow-carb vice photo booth scenester knausgaard.
XOXO street art pinterest pork belly succulents, fingerstache semiotics jean shorts. Flexitarian iPhone echo park ugh, +1 microdosing church-key artisan keytar. Offal vegan chia edison bulb drinking vinegar, ramps post-ironic cray activated charcoal vaporware four loko. Stumptown schlitz synth shabby chic tote bag.


{% extends "webpage_design/base.html" %} {% load static from staticfiles %} {% block content %}
Jewel of the north east
Queen of the hills.
Rivers.
Dominoes??
NJP and Bagdogra included
There is a big aquarium out here.


Some social networks want to be your stage manager: they put your life on display for audiences both intended (e.g. your friends, your family) and unintended (e.g. advertisers and misbehaving applications).
Footlights is different.
Footlights lets you choose how to present yourself to all of the audiences in your life. Share however much—or however little—you like, with anybody; this is your show. We've built the venue, but this is your production.
All the world's a stage... it's time to express yourself.


Newsletter Studio UI / UX
- Current situation
- Improve highlighting
- Drag scenarios & ordering
- Another problem arises
- What are we actually dragging?
- Other sort options
- Related future features
- Q&A
Values
- Go for no obstruction
- Incremental
- Provide multiple work paths
- Communicate with the user


public class Quadric3f
extends java.lang.Object
A quadric is implicitly represented by the formula:
q1i2 + q2j2 + q3k2 + q4xy + q5yz + q6zx + q7i + q8j + q9k +q0 = 0
This representation allows arbitrary orientation and positioning of quadric shapes. If we limit our consideration to quadric shapes that are centered at the origin and have the Z axis as the major axis of the quadric, the families of quadric shapes are represented as:
Elliptical Cylinder about k: q1 = 1/ri2 ; q2 = 1/rj2 ; q0 = -1
Ellipsoid: q1 = 1/ri2 ; q2 = 1/rj2 ; q3 = 1/rk2 ; q0 = -1
Elliptic Paraboloid about k: q1 = 1/ri2 ; q2 = 1/rj2 ; q9 = -1/height
Elliptic Cone about k: q1 = 1/ri2 ; q2 = 1/rj2 ; q3 = -1/height2
Hyperboloid about k: q1 = 1/ri2 ; q2 = 1/rj2 ; q3 = -1/rk2 ; q0 = -1
Hyperbolic Paraboloid about k: q1 = 1/ri2 ; q2 = -1/rj2 ; q9 = -1/rk
We intersect a ray starting at point (io,jo,ko) and extending in direction (i,j,k), the points along which are expressed as (it,jt,it) = (io,jo,ko) + t(i,j,k) where t is the distance from the origin of the ray (our standard parametric representation of a ray) by doing a bunch of algebraic gymnastics until we can express the combined equations as:
t2(q1i2 + q2j2 + q3k2 + q4 ij + q5jk + q6ki) +
t(2(q1ioi + q2joj + q3kok)+ q4(ioj + joi) + q5(jok + koj) + q6(koi + iok) + q7i + q8j + q9k) +
(q1io2 + q2jo2 + q3ko2 + q4 iojo+ q5joko + q6koio + q7io + q8jo + q9ko + q0) = 0
or, put another way:
at2 + bt + c = 0
where
a = q1i2 + q2j2 + q3k2 + q4 ij + q5jk + q6ki
b = 2(q1ioi + q2joj + q3kok)+ q4(ioj + joi) + q5(jok + koj) + q6(koi + iok) + q7i + q8j + q9k
c = q1io2 + q2jo2 + q3ko2 + q4 iojo+ q5joko + q6koio + q7io + q8jo + q9ko + q0
and we can use the quadratic formula to find the roots for t. Note that for our special case of location and orientation, these simplify considerably to:
a = q1i2 + q2j2 + q3k2
b = 2(q1ioi + q2joj + q3kok) + q9k
c = q1io2 + q2jo2 + q3ko2 + q9ko + q0
To find the normal at a point on the surface, we can take the partials of the formula and express the normal (in,,jn,kn) as:
u = 2q1i + q4j + q6k + q7
v = 2q2j + q4i + q5k + q8
w = 2q3k + q5j + q6i + q9
in = u / sqrt(u2 + v2 + w2) ; jn = v / sqrt(u2 + v2 + w2) ; kn = w / sqrt(u2 + v2 + w2)
As in the case of the coefficients of the quadratic form, the U, V, and W for normal computation also simplify substantially to:
u = 2q1i
v = 2q2j
w = 2q3k + q9
| Modifier and Type | Field and Description |
|---|---|
Quadric3f |
m_next
A pointer to tne next Quadric3f in a cache if this object is cached.
|
| Constructor and Description |
|---|
Quadric3f()
Creates a new instance of Quadric3f initialized to a unit sphere.
|
| Modifier and Type | Method and Description |
|---|---|
Quadric3fIntersection |
getIntersection(Quadric3fIntersection quadInt,
Line3f ray,
boolean bStartsInside)
Get the intersection of a ray, ray, with this quadric.
|
Quadric3fIntersection |
getIntersection(Quadric3fIntersection quadInt,
Point3f pt,
Vector3f v,
boolean bStartsInside)
Get the intersection of a ray starting at point pt in the direction v with this quadric.
|
Vector3f |
getNormal(Vector3f v,
Point3f pt)
Computes the normal for a point on the surface of the quadric.
|
float |
getQ(int index)
Get the quadric coefficient at the specified index.
|
@NotNull java.lang.String |
getQuadricType()
|
boolean |
isConvex()
Inquire whether this quadric is convex.
|
boolean |
isInside(Point3f pt)
Tests whether a point is inside ot outside a quadric.
|
Quadric3f |
setEllipsoid(float fRx,
float fRy,
float fRz)
Initializes the coefficients of the quadric formula for an
ellipsoid as: q1 = 1/ri2 ;
q2 = 1/rj2 ;
q3 = 1/rk2 ; q0 = -1
|
Quadric3f |
setEllipticalCone(float fRx,
float fRy,
float fHeight)
Initializes the coefficients of the quadric formula for an
elliptic cone about k as: q1 = 1/ri2
; q2 = 1/rj2 ; q3 = -1/height2
|
Quadric3f |
setEllipticalCylinder(float fRx,
float fRy)
Initializes the coefficients of the quadric formula for an
elliptical cylinder about k as: q1 = 1/ri2
; q2 = 1/rj2 ; q3 = 0 ; q0 = -1
|
Quadric3f |
setEllipticalParaboloid(float fRx,
float fRy,
float fHeight)
Initializes the coefficients of the quadric formula for an
elliptic paraboloid about k: q1 = 1/ri2
; q2 = 1/rj2 ; q9 = -1/height
|
Quadric3f |
setHyperbolicParaboloid(float fRx,
float fRy,
float fRz)
Initializes the coefficients of the quadric formula for a
hyperbolic paraboloid about j as: q1 = 1/ri2 ;
q2 = -1/rj2 ; q9 = -1/rk
|
Quadric3f |
setHyperboloid(float fRx,
float fRy,
float fRz)
Initializes the coefficients of the quadric formula for a
hyperboloid about k as: q1 = 1/ri2 ;
q2 = 1/rj2 ; q3 = -1/rk2 ; q0 = -1
|
public Quadric3f m_next
public Quadric3f()
public Quadric3f setEllipticalCylinder(float fRx, float fRy)
The elliptical cone is an ellipse of radius fRx, fRy centered at 0,0 where it cuts through the XY plane. It extends infinitely in Z.
fRx
- (float, > 0.0f) The i radius of the elliptical-cylinder.fRy
- (float, > 0.0f) The j radius of the elliptical-cylinder.public Quadric3f setEllipsoid(float fRx, float fRy, float fRz)
The ellipsoid is centered at 0,0,0.
fRx
- (float, > 0.0f) The i radius of the ellipsoid.fRy
- (float, > 0.0f) The j radius of the ellipsoid.fRz
- (float, > 0.0f) The k radius of the ellipsoid.public Quadric3f setEllipticalParaboloid(float fRx, float fRy, float fHeight)
The elliptical paraboloid has an elliptical cross section centered on the Z axis. The elliptic cross section has i and j radii of fRx,fRy where k = fHeight and k = -fHeight.
fRx
- (float, > 0.0f) The i radius of the cross section where k = fHeight.fRy
- (float, > 0.0f) The j radius of the cross section where k = fHeight.fHeight
- (float, > 0.0f) The k distance from the origin at which the elliptic cross section has i and j
radii of fRx,fRypublic Quadric3f setEllipticalCone(float fRx, float fRy, float fHeight)
The elliptical cone has an elliptical cross section centered on the Z axis. The elliptic cross section has i and j radii of fRx,fRy where k = fHeight and k = -fHeight.
fRx
- (float, > 0.0f) The i radius of the cross section where k = fHeight and k = -fHeight.
fRy
- (float, > 0.0f) The j radius of the cross section where k = fHeight and k = -fHeight.
fHeight
- (float, > 0.0f) The k distance from the origin at which the elliptic cross section has i and j
radii of fRx,fRypublic Quadric3f setHyperboloid(float fRx, float fRy, float fRz)
The hyperboloid has an elliptical cross section of radius fRx, fRy centered at 0,0 where it cuts through the XY plane. It extends infinitely in Z and flares out (gets larger) as it gets further from k.
fRx
- (float, > 0.0f) The i radius at k = 0.fRy
- (float, > 0.0f) The j radius at k = 0.fRz
- (float, > 0.0f) The k 'radius'. This is not really a radius because the hyperboloid extends
infinitely.  Note that as fRz approaches infinity the q3 term approaches 0 and the hyperboloid becomes an
elliptical cylinder.
public Quadric3f setHyperbolicParaboloid(float fRx, float fRy, float fRz)
fRx
- The i 'radius'.fRy
- The j 'radius'.fRz
- The k 'radius'.public float getQ(int index)
index
- The index, from 0 to 9 as described in the class documentation.@NotNull public @NotNull java.lang.String getQuadricType()
public boolean isConvex()
public boolean isInside(Point3f pt)
pt
- (readonly) The point to be tested.public Quadric3fIntersection getIntersection(Quadric3fIntersection quadInt, Point3f pt, Vector3f v, boolean bStartsInside)
quadInt
- (modified) The intersection.pt
- {readonly} The origin of the ray.v
- {readnoly} The direction of the ray.bStartsInside
- false if this is an outside ray, true if this is a ray
spawned from an intersection with this object and on the inside of the object. NOTE: this is a logic
decision and must be respected - specifically, if the ray starts inside it was because a previous call
to this method reported the intersection from the outside. Thus, the only possible next intersection
is going out.public Quadric3fIntersection getIntersection(Quadric3fIntersection quadInt, Line3f ray, boolean bStartsInside)
quadInt
- The intersection.ray
- The ray.bStartsInside
- false if this is an outside ray, true if this is a ray
spawned from an intersection with this object and on the inside of the object.public Vector3f getNormal(Vector3f v, Point3f pt)
v
- (Vector3f, modified) The normal.pt
- (Point3f, readonly) The point on the surface of the quadric.


Home
Insilico (CE)
Collisions (CH)
Creato (CL)
Resonance (EC)
Instronics (IC)
Tech Crusade (IT)
Techno Kshetra (BCA)
Bizz Brainz (MBA)
Dimensions (MH)
Cultural
Central Events
Poster Presentation
Techno Quiz
Web Hunt


Oracle's Class Of program offers recent college graduates the unqiue experience of
Oracle's Class Of program offers recent college graduates the unqiue experience of
Oracle's Class Of program offers recent college graduates the unqiue experience of
What is tech consulting?
Oracle's Class Of Technology Consulting program helps recent college graduates quickly design, develop, and deliver Oracle technology solutions in Oracle Cloud.
Meet the team
Oracle's Class Of Technology Consulting program helps recent college graduates quickly design, develop, and deliver Oracle technology solutions in Oracle Cloud.
The recruitment process
Apply to Oracle Class of Tech Consulting and find out what to expect from the interiew process. Learn some tips and tricks to nailing the interview.


Fill in the form below to generate a link to Hosted Payment Page to provide to a customer
Enter any custom values you would like to be recorded with the payment


 Just never had taken a prescription for it. I started to see a shrink a couple of years ago. He thought I was depressed, tried every Depression drug on this earth. But nothing worked. He just prescribed and kicked me out the door. So I decided to try a different shrink. This one told me I was 100% ADD. I told this one that I knew I was, and have been. But nobody ever listened. So she prescribed me Adderall. 5 mg a day for the first week. All I have to say is Awesome. Works like a charm. I could think better. Get everything I needed done. Then she bumped me up to 10mg. Thats when I start to feel like my world has come together. Everything is going in the Right direction. She stated if I needed to bump it up ago, just let her know. So I started taking 20mg a day. Ever since this. I feel like a complete person.
On to the effects. At first it was very focused, alive. Speedy effects like meth. I guess this is why I did meth in my days and liked it. Cause it made my brain straight.
The drug does wonders. I have no side effects except headaches from staying awake after coming down off of it. Like after I have been drinking and stay awake and the headache comes on. Just like that.
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


Some Of Davido’s Outstanding Achievements In 2019
by Oyindamola OlubajoYear 2019 has obviously been a good year for Nigerian singer Davido as he keeps earning several feats for himself and his career.
Davido has over time carved a niche for himself in the showbiz and has been the favourite of many afrobeat lovers.
As the singer clocks 27 on November 21, this platform takes time to examine some of his achievements.
- Davido bagged award in Crossing Boundaries Music category of African Muzik Magazine Awards (AFRIMMA) im October.
- The 30 Billion gang crooner has attained an impressive position of being the seventh on the list of most influential African people in the world.
- He made a record on YouTube, as his popular single, ‘Fall’ hits 150 million views on YouTube. This feat is said to be a milestone for afrobeats as Davido’s ‘Fall’ becomes the first afrobeat record to achieve such number of views.
- Davido set another record for himself as he becomes the first African celebrity to hit one million likes on a post on Instagram after he shared a photo of himself and his newborn, Adedeji David, whom he welcomed in the early hours of Sunday, October 20.
- He was ranked the richest Nigerian on Instagram, with his single post valued at over N26 million. The Instagram Rich List 2019 by Hopper HQ 2019 also reveals that Davido stands at second position in Africa and occupies 38 positions on global rating.
- He also earned some accolades for himself as he became the most viewed Nigerian artist on streaming platform, YouTube. Davido had over 500 million views across all his uploads on the platform.
- The ‘Aye’ crooner also made history by becoming the first Nigerian artiste to hit 13 million followers on social media network, Instagram.
- Davido finally proposed to his longtime girlfriend, ChiomaRowland in September.
- The DMW boss welcomed his first male child, David junior on October 20.


[Gecode] Moving the CVS
Guido Tack
tack at ps.uni-sb.de
Tue Jul 27 13:51:11 CEST 2004
Christian Schulte wrote:
> Good idea, maybe I can add some more comments:
> - The root is good
> - For the web I propose the module www as directory
> - For the system I propose gecode
> - Then we should move stuff such as benchmarks and doc out of the gecode
> directory
> - The upload to the webserver should be done by a script only (going to
> grizzly, doing the cvs up, and also the proper permissions). The idea is
> that nobody ever goes there but the script.
Actually, it shouldn't go to grizzly but www.gecode.org ;-)
> - All webpages should be done using php from the start
> - The webpages hsould clearly reflect general information and version
> specific information (one of the mistakes we did with Mozart)
Yes, I completely agree. I have set up the new CVS. Please check in everything
you have in your local copies and tell me when you're ready so that I can do
the move - unless it's so much that we should wait another week ;-)
Guido
--
Guido Tack
Programming Systems Lab
http://www.ps.uni-sb.de/~tack
More information about the gecode-users
mailing list


ia_precincts.Rd
Precinct and district shapefiles are published by the Secretary of State. Election results of the 2016 general election are added to each precinct.
ia_precincts
A data frame with 1690 rows and 16 variables:
county
DISTRICT, precinct and NAME are used as names of a precinct.
DISTRICT, precinct and NAME are used as names of a precinct.
DISTRICT, precinct and NAME are used as names of a precinct.
population of the precinct.
Total number of votes cast in the US general election for US President.
Percent of votes in the district cast for the candidate of the Republican Party
Percent of votes in the district cast for the candidate of the Democratic Party
Percent of votes in the district cast for the candidate of the Libertarian Party
Percent of votes in the district cast for a candidate of an other party.
House district affiliation
Senate district affiliation
Congression district affiliation
Area of the district.
Numeric value derived from polygon.
sfc object of polygons describing each district.
https://sos.iowa.gov/elections/maps/shapefiles.html
library(leaflet) pal <- colorNumeric(palette=c("Darkred", "White", "Darkblue"), reverse = TRUE, domain = range(ia_precincts$PctRep16 - ia_precincts$PctDem16, na.rm=TRUE)) ia_precincts %>% leaflet() %>% addTiles() %>% addPolygons(fillColor = ~pal(PctRep16-PctDem16), fillOpacity = .75, stroke=0, opacity = 1, label=~NAME) %>% addLegend(pal=pal, values = range(ia_precincts$PctRep16 - ia_precincts$PctDem16, na.rm=TRUE))


This library allows you to detect an irregular heart rate, find times where the user's heart is at risk and perform calculations around user specific heart rate data (MHR & THR). It was based off our old product called Cure Band and inspired after Arsh's grandfather suffered multiple cardiac arrests at home.
Our main team consists of:


Throttle a function
$ component install component/throttle
var throttle = require('throttle');
window.onresize = throttle(resize, 200);
function resize(e) {
console.log('height', window.innerHeight);
console.log('width', window.innerWidth);
}
Creates a function that will call fn
at most once every wait
milliseconds.
Supports leading and trailing invocation.
fn
will receive last context (this
) and last arguments passed to a throttled wrapper before fn
was invoked.
MIT


About us
Hi. I'm Kate and La Meva Casa is my baby and my passion. It started
with a corner in my garage and an idea. Any one that knows me laughs at
the idea of me selling gifts, collectables and decor. My home is
country meets modern industrial meets something that isn't even named!
My eclectic style is represented in the products we sell from the
practical canisters and placemats to the weird Gold Wooden
Pineapples.
Now out of the garage and in our own office my hubby and my rock has
joined La Meva Casa. He is everything I am not. Practical, organised
and not impulsive! He brings to La Meva Casa his years of involvement
in management and logistics helping to keep everything running
smoothly.
We also have our first employee Jaz, our wonderful, eye twitching
organiser and postage girl. She wraps and packs and sends the oddest
things all over Australia from the poly resin lamb to Tasmania to the
huge metal Tree of Life to Karratha in WA. In fact i buy odd size
things just to give Jaz a challenge and Jaz always rises to the
occasion.
So together we form La Meva Casa. We pride ourselves on our
exceptional customer service while delivering products that are
affordable without compromising on quality or style.
So join us on this journey we take and make La Meva Casa - Your Home
- for gifts and collectables. (And everything in between)!
Returns
When shopping online we want to ensure you are happy with your
purchase and feel good about the experience of shopping with us. If
for any reason you are not pleased with the items purchased online,
or if it is not what you expected, you have the option of returning
the item to us for a full refund of the product price subject to
the following conditions:
Return policy is valid for 30 days;
If you simply have changed your mind, the refund will be for the
product price only and not the postage cost;
If you post the item to us, you do so at your own expense; and
The item must be returned in original condition and packaging
within 14 days of receipt.
Faulty or Damaged Goods
Please Contact Us to discuss the faulty items and to obtain our
reply paid address.
Please note that refunds can only be issued to the bank account
or PayPal account that was originally charged.


[one] This paragraph’s color has 0% saturation.
[two] This paragraph’s color has 0% saturation.
[three] This paragraph’s color has 0% saturation.
[four] This paragraph’s color has 0% saturation.
[five] This paragraph’s color has 0% saturation.
[six] This paragraph’s color has 0% saturation.
[seven] This paragraph’s color has 0% saturation.
[one] This paragraph’s color has 50% saturation.
[two] This paragraph’s color has 50% saturation.
[three] This paragraph’s color has 50% saturation.
[four] This paragraph’s color has 50% saturation.
[five] This paragraph’s color has 50% saturation.
[six] This paragraph’s color has 50% saturation.
[seven] This paragraph’s color has 50% saturation.


| When? | Service | Interface change | Change |
|---|---|---|---|
| 2014-07-18 | PUT songLibrary | Yes | Return full description for all updated songs. The return JSON now contains a full description of everything we know about the song on the server. This includes all of the details about the users individual preferences about the sang AND all the details about the master record of the song. Probably of most importance to developer are the (potentially recalculated) energy field, and the potentially altered fields of topGenre, subGenre and tempo. |
| 2014-06-20 | POST/PUT/GET songLibrary | Yes | 2 likability data field changes in the JSON. (1) isFavorite changed to isSonomaFavorite. There is no favoriting done in iTunes, so this will not be used in "POST songLibrary". (2) changed bookMarkedTime to sonomaFavoriteDate This is the epoch time that the user favorited the song in sonoma. |
| 2014-06-20 | POST/PUT/GET songLibrary | Yes | multiple likability field changes. (1) added addDate to mark epoch time that a song was added to the library. (2) changed appearsInPlayList (a boolean value) to playListCount to identify the number of play lists the song is a part of. Assumption: Songs that are included in more playlists are more liked by the user. (3) added isMusic boolean field. There is a need to filter out audio books, spoken word and other non-music audio files from the audio files which contain music. |
| 2014-06-20 | POST/PUT/GET songLibrary | Yes | multiple genre field changes. (1) Differentiation between topGenre and subGenre. Our energy calculation algorithms require us to differentiate between these 2 different types of iTunes genres. Our goal should be to ascertain the subGenre. However, if in lieu of this, identifying the top level genre is better than not identifying any genre at all. (2) Client-side genre processing: In the request, we used to send just a single genre field called "iTunesGenre". This contains whatever genre information that the user currently has in their iTunes record for that song. Now, it is anticipated that the client may execute a local algorithm to change this value. Fields are now provided for both of these data items. Summary of changes 3 fields will be sent: clientRawGenre, clientTopGenre and clientSubGenre The first is the raw unprocessed genre that exists before processing. The second is the genre that has been processed by the client. Currently we expect that this "processing" is a simple check against a list of recognized genres. In the future, more sophisticated client-side genre mapping algorithms may be used. There is also a change in the data returned by the server. For each song, we will return 5 fields: clientRawGenre, serverTopGenre and serverSubGenre, Example: "clientRawGenre": "Hip Hop", "clientTopGenre": "", "clientSubGenre": "" "serverTopGenre": "Hip-Hop/Rap", "serverSubGenre": "Gangsta Rap", In addition to this, response JSON also contains a link to the master record for each song. This master record used to contain a simple genre field. The master record will now contain the following 2 fields: topGenre and subGenre. |
| 2014-05-30 | PUT songLibrary | No | Share new tempo info with other users. If the tempo is updated, we attempt to offer value to other users by sharing this information with them. We update both the tempo and the energy fields in the master record of the song. New users will automatically get this information as soon as they add the same song to their library. Existing users who already have this song in their library will not be updated. It is assumed that they will calculate the tempo information themselves very quickly. However, AFTER calculating the tempo for the songs they don't have that information for and sending this information to the sever via this service, they SHOULD request updated energy numbers for those songs, because these very likely will have changed. |
| 2014-05-30 | PUT songLibrary | Yes | Retrieve new energy numbers for songs whose tempo has changed. The JSON returned along with a 201 status code has changed. Before, nothing was returned. Now, if the PUT request specified new tempo info for the song, the response will contain the newly calculated energy for the song. It will also contain some of the variables used to calculate it. |
| 2014-05-28 | POST songLibrary | Yes | Now returns energy level for every song added. We now return a (1) genre [try], (2) tempo [try] and (3) energy [guaranteed] for every song uploaded. The return JSON has changed to reflect this. |
| 2014-05-28 | POST songLibrary | Yes | removed the userId input parameter from the JSON Now checks to ensure that the account being used to create a library actually exists. Previously users could subvert this check by authentication with one user in the "Authorization" header and then creating the songLibrary for another user. The bug has been fixed by eliminating the practice of sending up 2 different userId parameters. We now use the userId in the Authorization header only. |
| 2014-05-28 | POST songLibrary | No | Restricted the number of songs uploaded to 100 per request. This upper bound is needed to ensure that processing can be completed quickly enough to return a timely response to the client. As processing speeds are improved, this limit may be increased. |
| 2014-05-29 | PUT songLibrary | Yes | changed the name of the input parameter from id to songLibraryId This has been done though all of the methods of the songLibrary resource to alleviate confusion. |


FROM THE DESK OF RAJI RAJI BILL AND EXCHANGE MANAGER, AFRICAN DEVELOPMENT BANK (ADB) OUAGADOUGOU, BURKINA FASO. Dear Friend, How are you,first i will explain my self little to you before we continue. I am the manager of bill and exchange at the foreign remittance department of AFRICAN DEVELOPMENT BANK (ADB)I am writing to seek your interest over a transaction. In my department we discovered an abandoned sum of $15m US dollars (FIFTEEN MILLIONS US DOLLARS) . In an account that belongs to one of our foreign customer who died along with his entire family in November 2001 in a plane crash. Since we got information about his death, we have been expecting his next of kin to come over and claim his money because we cannot release it unless somebody applies for it as next of kin or relation to the deceased as indicated in our banking guidelines but unfortunately we learnt that all his supposed next of kin or relation died alongside with him at the plane crash leaving nobody behind for the claim. It is therefore upon this discovery that I and one other official in my department have decided to make this business proposal to you and release the money to you as the next of kin or relation to the deceased for safety and subsequent disbursement since nobody is coming for it and we don�t want this money to go into the Bank's treasury as unclaimed Bill. The Banking law and guideline here stipulates that if such money remained unclaimed after five years, the money will be transferred into the Bank's treasury as unclaimed fund. The request of foreigner as next of kin in this business is occasioned by the fact that the customer was a foreigner and a Burkinabe cannot stand as next of kin to a foreigner. We agree that 40 % of this money will be for you as foreign partner, in respect to the provision of a foreign account, 10 % will be set aside for expenses incurred during the business and 50 % would be for me and my colleague. There after I will visit your country for disbursement of the fund according to the percentages indicated in this proposal. Therefore to enable the immediate transfer of this fund to you as arranged, you must apply first to the bank as relations or next of kin of the deceased indicating your bank name, your bank account number, your private telephone and fax number for easy and effective communication and location where in the money will be remitted. Upon receipt of your reply, I will send to you by email the text of the application. I will not fail to bring to your notice that this transaction is hitch free and that you should not entertain any atom of fear as all required arrangements have been made for the transfer . You should contact me immediately as soon as you receive this letter. Trusting to hear from you immediately. Your�s faithfully RAJI RAJI Bill and Exchange Manager, Africa Development Bank (A.D.B) _________________________________________________________________ Découvrez Windows Live Messenger : le futur de MSN Messenger ! www.windowslivemessenger.fr


This is a simple snippet saving tool directed toward programmers looking for a space to save small segments of code.
Use this tool to keep your frequently used functions and blocks of code organized in one area.


Historical Files
The git tree available here was imported from the FreeRADIUS CVS tree at cvs.freeradius.org. For speed, a local copy was used:
radiusd-cvs.freeradius.org.tar.gz (10 MB) radiusd-cvs.freeradius.org.tar.gz.sig
The git import command was:
$ git cvsimport -kam -d ./source -C ./freeradius-server.git radiusd
If you want to reproduce the git tree yourself, you will need to create a CVSROOT directory with the appropriate information in it.
This archive is strictly for historical purposes, and should be of little interest to most people. The same information is available in the git tree.
cvs.freeradius.org
For now, the original source tree at cvs.freeradius.org is still available.


The API Specification Toolbox is a community project and runs 100% on Github so that anyone can submit a pull request and add or update any of the tools listed here on the toolbox. You can find the tools all listed in the _tools folder in the repo, and each tool has a single YAML file stored as an .md file. Using YAML front end matter to publish the data to the listing and detail pages.
To update or add tools to the site you can fork the repository for the project, add or update any of the files, and then submit a pull request with all the changes. If you don't feel comfortable submitting a pull request you can just submit an issue using the "new-tools" label. If you are looking to help, we can really use assistance with some data entry, adding any of the existing tools that have been submitted as a Github issue--we really appreciate the community contribution.


No more waiting for your turn to bat
No more fielding
More fun than the good ol' days
Simply press Play!
The ball speed, swing and pitch can be varied. In single player mode, the pitch is randomly changed to simulate a real bowler. Similarly, the swing can also be changed to simulate real match conditions.
The ball speed, swing and pitch can be varied. In single player mode, the pitch is randomly changed to simulate a real bowler. Similarly, the swing can also be changed to simulate real match conditions.
We track your hits in real time using a sophisticated array of trackers and software to give you a score based on the direction, angle and exit velocity of your hit.


Next: function-lambda-expression, Previous: funcall, Up: Data and Control Flow Dictionary
function
name ⇒ function
name—a function name or lambda expression.
function—a function object.
The value of function is the functional value of name in the current lexical environment.
If name is a function name, the functional definition of that name is that established by the innermost lexically enclosing flet, labels, or macrolet form, if there is one. Otherwise the global functional definition of the function name is returned.
If name is a lambda expression, then a lexical closure is returned. In situations where a closure over the same set of bindings might be produced more than once, the various resulting closures might or might not be eq.
It is an error to use function on a function name that does not denote a function in the lexical environment in which the function form appears. Specifically, it is an error to use function on a symbol that denotes a macro or special form. An implementation may choose not to signal this error for performance reasons, but implementations are forbidden from defining the failure to signal an error as a useful behavior.
(defun adder (x) (function (lambda (y) (+ x y))))
The result of (adder 3) is a function that adds 3 to its argument:
(setq add3 (adder 3)) (funcall add3 5) ⇒ 8
This works because function creates a closure of the lambda expression that is able to refer to the value 3 of the variable x even after control has returned from the function adder.
defun, fdefinition, flet; labels; macrolet, labels, symbol-function, Symbols as Forms, Sharpsign Single-Quote, Printing Other Objects
The notation #'name may be used as an abbreviation for (function name).
Next: function-lambda-expression, Previous: funcall, Up: Data and Control Flow Dictionary


La bohème is an opera in four acts, composed by Giacomo Puccini between 1893 and 1895 to an Italian libretto by Luigi Illica and Giuseppe Giacosa, based on Scènes de la vie de bohème (1851) by Henri Murger. The story is set in Paris around 1830, and shows the Bohemian lifestyle (known in French as "la bohème") of a poor seamstress and her artist friends. The world premiere of La bohème was in Turin on 1 February 1896 at the Teatro Regio,[3] conducted by the 28-year-old Arturo Toscanini. Since then, La bohème has become part of the standard Italian opera repertory and is one of the most frequently performed operas worldwide.


Configuring your application
Introduction
The FuelPHP framework is built with configuration over convention in mind. This results in a highly customizable base on which you can start building your application.
Configuration files are stored inside the app/config folder. The application's basic configuration is done in app/config/config.php. The loaded configuration can be made environment specific, more on this under Environments.
To overwrite settings from feature specific configs, either create a new file in app/config or copy the corresponding file from core/config to app/config.
Configuration options
These are the options that can be defined in the applications basic configuration file, app/config/config.php . When you have just installed FuelPHP, this file is empty. All default values, as defined below, are defined in the corresponding file in the core/config folder. When you want to override a default, add the key to the array in your app config file, and modify the value. Alternatively, copy the section from the core file to the app file, and modify it.
FuelPHP uses "dot-notation" when handling arrays. It is a convenient way of accessing elements of a multi-dimensional array. This notation is used in the documenation as well, as it provides an easy to type array reference. For example:
// when you see "always_load.packages = array()", it is shorthand for:
array("always_load" => array("packages" => array(...) ) );
| Key | Type | Default | Description |
|---|---|---|---|
| base_url | string |
|
The base URL of the application. Can be relative. MUST contain a trailing slash. ('/foo/', 'http://example.com/') |
| url_suffix | string |
|
Any suffix that needs to be added to URL's generated by Fuel. If the suffix is an extension, make sure to include the dot. ('.html') |
| index_file | string |
|
The name of the main bootstrap file. Set this to false or remove if you using mod_rewrite. |
| controller_prefix | string |
|
The class prefix used to find controllers when mapping the URI to the controller class name. You have to change this if you want your controllers namespaced or in a different folder then app/classes/controller. |
| profiling | bool |
|
Whether to enable the profiler. |
| cache_dir | string |
|
The directory to store cache files in. This directory must be writable. |
| caching | bool |
|
Whether to enable file finder caching. |
| cache_lifetime | int |
|
The file finder cache lifetime in seconds. |
| ob_callback | callback |
|
Callback given to ob_start(), set to ob_gzhandler to enable gzip encoding of output. |
| errors | array | Array, containing the configuration keys to control behaviour when detecting errors: | |
| errors.continue_on | array |
|
On which php errors to proceed execution. See Error handling. |
| errors.throttle | int |
|
How many errors to show before we stop showing them. (prevents out-of-memory errors) |
| errors.notices | bool |
|
Whether to show notices. |
| language | string |
|
The default application language, used by the Lang class. |
| locale | string |
|
Used for setlocale() required on some php
installations, set to false to prevent it from being
set. The syntax setting for this can differ per OS, Ubuntu for example requires a .utf8 (the encoding) suffix. |
| encoding | string |
|
The application's default character encoding. |
| server_gmt_offset | int |
|
The offset in seconds the server offset from gmt
timestamp when time() is used. This is only to correct bad server configuration: time() should always return the number of seconds since January 1 1970 00:00:00 GMT. |
| default_timezone | string |
|
The server timezone. |
|
If you set this value, make ABSOLUTELY sure that the timezone configured matches the timezone set on your server. Since timezone calculations work by converting to GMT, it goes horribly wrong when you have a timezone mismatch. This will cause time displays in your application to be incorrect, and cookie/session issues due to incorrect expiry time calculations! |
|||
| log_threshold | int |
|
The logging threshold. From what level of message to log, or an array of specific message levels that should be logged. Read about the possible values |
| log_path | string |
|
The directory to store the logs in. This directory MUST be writable. |
| log_date_format | string |
|
The date/time format used in the logs. |
| security | array | Array, containing the configuration keys to control your application security: | |
| security.csrf_autoload | bool |
|
Whether to auto-check the csrf token. Read more about csrf. |
| security.csrf_token_key | string |
|
Which $_POST key to fetch when checking the csrf token. |
| security.csrf_expiration | int |
|
Set the expiration time for the csrf cookie. Anything higher than 0 is the number of seconds in which the cookie will expire. |
| security.token_salt | string |
|
A salt to make sure the generated security tokens are not predictable. |
| security.allow_x_headers | bool |
|
Allow the Input class to use "X" headers when present, such as HTTP_X_FORWARDED_FOR or HTTP_X_FORWARDED_PROTO. |
| security.uri_filter | array |
|
What php functions to use to filter the URI. |
| security.input_filter | array |
|
What php functions filter the input arrays ($_GET, $_POST and $_COOKIE). Can be set to xxs_clean, this may cause a performance hit based on the size of the input. |
| security.output_filter | array |
|
What php functions filter the variables set to a view. Can be set to xxs_clean, this may cause a performance hit based on the size of the variables. |
| security.auto_filter_output | bool |
|
Whether to automatically encode (htmlentities) view data. |
| security.whitelisted_classes | array() |
|
With output encoding switched on all objects passed will be converted to strings or throw exceptions unless they are instances of the classes in this array. |
| cookie | array | Array, containing the configuration keys define the global cookie settings: | |
| cookie.expiration | int |
|
Number of seconds before the cookie expires. |
| cookie.path | string |
|
Restrict the path that the cookie is available to. |
| cookie.domain | string |
|
Restrict the domain that the cookie is available to. |
| cookie.secure | bool |
|
Only transmit cookies over secure connections. |
| cookie.http_only | bool |
|
Only transmit cookies over HTTP, disabling Javascript access. |
| module_paths | array |
|
Paths to module directories. Used when adding a module without specifying the location. |
| always_load | array | Array, containing the items the framework has to load when it initializes: | |
| always_load.packages | array |
|
Which packages to autoload. Specify like so: array('package') or array('package' => PKGPATH.'path/to/package'). In order for this to work a package path must be set in package_paths |
| always_load.modules | array |
|
Which modules to autoload. Specify like so: array('package'). Autoloaded modules are accessible via the URL. In order for this to work a module path must be set in module_paths |
| always_load.classes | array |
|
Which classes to autoload and initiate. When you want to autoload a class from a package or module, make sure that is autoloaded too! |
| always_load.config | array |
|
Which config files to autoload. Load a config file into a group like so: array('config') or array('filename' => 'group'). If you do not want to load the file into a set the group name to null: array('filename' => null). |
| always_load.language | array |
|
Which language files to autoload. Load a config file into a group like so: array('lang') or array('filename' => 'group'). If you do not want to load the file into a set the group name to null: array('filename' => null). |
Interacting with config files/settings is done using the Config class. Config files can also be generated using Oil.


Conditional probabilities are quite subtle. Apart from the common mistake of confusing $\mathbf{P}(A\ \pmb{\big|} \ B)$ for $\mathbf{P}(B\ \pmb{\big|} \ A)$, there are other points one sometimes overlooks. In fact, most of the paradoxical sounding puzzles in probability are based on confusing aspects of probability. Let us see one.
Question 72
A man says ''I have two children, and one of them is a boy''. What is the chance that the other one is a girl?
There are four possibilities $BB, BG,GB,GG$, of which $GG$ has been eliminated. Of the remaining three, two are favourable, hence the chance is $2/3$ that the other child is a girl. This is a possible solution. If you accept this as reasonable, here is another question.
Question 73
A man says ''I have two children, and one of them is a boy born on a Sunday''. What is the chance that the other one is a girl?
Does the addition of the information about the boy change the probability? One opinion is that it should not. The other is to follow the same solution pattern as before. Write down all the $2\times2\times7\times7$ possibilities: $BBss$ (boy, boy, sunday, sunday), $BBsm$, etc. The given information that one is a boy who was born on Sunday eliminates many possibilities and what remain are $27$ possibilities $BGt*$, $GB*t$, $BBt*$, $BB*t$ where $*$ is any day of the week. Take care to not double count $BBtt$ to see that there are $27$ possibilities. Of these, $14$ are favourable (i.e., the other child is a girl), hence we conclude that the probability is $14/27$.
Is the correct answer $14/27$ as calculated here or is it $2/3$ (since the information of the day of birth of the boy is irrelevant, why should we change our earlier answer of $2/3$?)?
We leave it as food for thought. If you want a hint, the point is that to compute conditional probabilities, it is not enough to know what the person said, but also what else he could have said. Not realizing this point is the main source of confusion in many popular puzzles in probability.


|
Helix
|
#include <TheMain.h>
Public Member Functions | |
| TheMain (char *p_config_file_name) | |
| virtual | ~TheMain () |
| Standard destructor. More... | |
| void | Execute (void) |
| This is how you start us up. More... | |
| ThreadList & | GetThreadList (void) |
| Returns the global ThreadList object. More... | |
| void | Shutdown (void) |
| Allows anyone to tell us to shutdown. More... | |
| bool | isShutdown (void) |
| Are we in a shutdown state? More... | |
| bool | isShutdownDone (void) |
| Has our shutdown finished? More... | |
| void | ReReadConfig (void) |
| xmlDocPtr | GetConfig (void) |
| Returns a pointer to our config document. More... | |
| void | SaveConfig (void) |
| Saves our current in-memory config document to the disk. More... | |
| twine & | GetConfigFileName (void) |
| Returns the name of our config file on disk. More... | |
| twine & | SystemName (void) |
| Returns our system name. More... | |
| const char * | ServerVersion (void) |
| Returns our server version. More... | |
| const char * | ServerBuiltOn (void) |
| Returns our server built-on date. More... | |
| BlockingQueue< IOConn * > & | getIOQueue (void) |
| Returns the global IO Queue that we maintain: More... | |
| void | DumpStateToLogs (void) |
| Dumps interesting things to the logs. More... | |
| OdbcObj & | GetOdbcConnection (twine &whichOne) |
| Replace this with a proper pool implementation. More... | |
| SqlDB & | GetSqlDB (const twine &whichOne) |
| Returns a SQL DB object that represnets an interface to one of our local databses. More... | |
| void | RefreshAdaptiveLogs (void) |
| Tell TheMain that something has changed in the config and AdaptiveLogs needs to be refreshed. More... | |
| AdaptiveLogs & | GetAdaptiveLogs (void) |
| Get a reference to the adaptive logs object. More... | |
| RSA * | GetKeypair (void) |
| Returns our public/private RSA keypair which can be used for encryption/decryption. More... | |
Static Public Member Functions | |
| static TheMain * | getInstance (void) |
| Use this to access the global instance of TheMain. More... | |
Private Member Functions | |
| TheMain () | |
| TheMain (const TheMain &c) | |
| TheMain & | operator= (const TheMain &c) |
| void | InternalExecute (void) |
| This is the real execute method. More... | |
| void | FindConfigFile (void) |
| Finds our config file. More... | |
| void | LoadConfig (void) |
| Loads our config file. More... | |
| void | CheckUpgrades () |
| Checks for any upgrades that need to be done for our config file. More... | |
| void | Handle510_511 () |
| Handles 510 -> 511 upgrades in our config file. More... | |
| void | GenConfig (void) |
| Autogenerates a default config file. More... | |
| void | InitLogs (void) |
| Sets up simple logging. More... | |
| void | FindKeys (void) |
| Finds our public/private keys. More... | |
| void | CreateKeys (void) |
| Creates our public/private keys if they don't exist. More... | |
| void | ReadKeys (void) |
| Reads our public/private keys from their standard files. More... | |
| void | TestEncrypt (RSA *keypair) |
| Test method to research RSA encryption/decryption. More... | |
| void | InitStorageDB (void) |
| Loads and starts our protocol masters. More... | |
| void | LaunchIOAdapters (void) |
| Loads and starts our IOAdapters. More... | |
| void | LoadIOAdapter (xmlNodePtr node) |
| Load and start a single IOAdapter. More... | |
| void | LoadProtocol (xmlNodePtr node) |
| Loads and starts one protocol. More... | |
| void | LaunchMsgProcScaler (void) |
| Launches all Processor processes. More... | |
| void | ShutdownThreads (void) |
| Shuts down threads we've launched. More... | |
| void | ShutdownLogger (void) |
| Shuts down our logger thread (do this last) More... | |
Private Attributes | |
| ThreadList * | m_threads |
| The global ThreadList object. More... | |
| twine | m_config_file_name |
| Our config file name. More... | |
| twine | m_system_name |
| Our system name. More... | |
| bool | m_shutdown |
| Should we shutdown now or not? More... | |
| bool | m_shutdown_done |
| vector< pair< Thread *, Threadable * > > | m_our_threads |
| map< twine, void * > | m_loaded_dlls |
| BlockingQueue< IOConn * > | m_io_queue |
| map< twine, ProtocolMaster * > | m_protocol_types |
| xmlDocPtr | m_config |
| This is our config file. More... | |
| int | m_transaction_id |
| This is the current transaction id for our system. More... | |
| Mutex * | m_transaction_mut |
| This is the mutex that protects access to the trans id. More... | |
| bool | m_is_shutdown_reconfig |
| Is the current shutdown only for a re-config cycle. More... | |
| OdbcObj * | m_odbc_conn |
| FIXME: use a real pool. More... | |
| map< twine, SqlDB * > | m_databases |
| Our list of local databases: More... | |
| AdaptiveLogs * | m_logger |
| This is our Adaptive Logger object. More... | |
| RSA * | m_keypair |
| This is our RSA keypair that is used to encrypt/decrypt our documents. More... | |
This class does double duty as our main execution body as well as holding any information that needs to be globally accessable. Instantiate this with the argc and argv values from the c main function, and then call Execute(). This will do the rest.
|
inlineprivate |
|
inlineprivate |
| TheMain::TheMain | ( | char * | p_config_file_name | ) |
Our main constructor allows the input of one command line argument as follows:
This will throw an exception if anything goes wrong.
|
virtual |
Standard destructor.
|
private |
Checks for any upgrades that need to be done for our config file.
|
private |
Creates our public/private keys if they don't exist.
| void TheMain::DumpStateToLogs | ( | void | ) |
Dumps interesting things to the logs.
| void TheMain::Execute | ( | void | ) |
This is how you start us up.
|
private |
Finds our config file.
|
private |
Finds our public/private keys.
|
private |
Autogenerates a default config file.
| AdaptiveLogs & TheMain::GetAdaptiveLogs | ( | void | ) |
Get a reference to the adaptive logs object.
| xmlDocPtr TheMain::GetConfig | ( | void | ) |
Returns a pointer to our config document.
| twine & TheMain::GetConfigFileName | ( | void | ) |
Returns the name of our config file on disk.
| BlockingQueue< IOConn * > & TheMain::getIOQueue | ( | void | ) |
Returns the global IO Queue that we maintain:
| RSA * TheMain::GetKeypair | ( | void | ) |
Returns our public/private RSA keypair which can be used for encryption/decryption.
| OdbcObj & TheMain::GetOdbcConnection | ( | twine & | whichOne | ) |
Replace this with a proper pool implementation.
| SqlDB & TheMain::GetSqlDB | ( | const twine & | whichOne | ) |
Returns a SQL DB object that represnets an interface to one of our local databses.
| ThreadList & TheMain::GetThreadList | ( | void | ) |
Returns the global ThreadList object.
|
private |
Handles 510 -> 511 upgrades in our config file.
|
private |
Sets up simple logging.
|
private |
Loads and starts our protocol masters.
Loads and creates any databases that we have defined
|
private |
This is the real execute method.
| bool TheMain::isShutdown | ( | void | ) |
Are we in a shutdown state?
| bool TheMain::isShutdownDone | ( | void | ) |
Has our shutdown finished?
|
private |
Loads and starts our IOAdapters.
|
private |
Launches all Processor processes.
Launches our message processor
|
private |
Loads our config file.
|
private |
Load and start a single IOAdapter.
|
private |
Loads and starts one protocol.
|
private |
Reads our public/private keys from their standard files.
| void TheMain::RefreshAdaptiveLogs | ( | void | ) |
Tell TheMain that something has changed in the config and AdaptiveLogs needs to be refreshed.
| void TheMain::ReReadConfig | ( | void | ) |
Allows anyone to tell us to re-read our config information. We will in turn, tell all of our sub-threads to re-read their config information. Call this whenever the config file changes so that everyone can react to it.
| void TheMain::SaveConfig | ( | void | ) |
Saves our current in-memory config document to the disk.
| const char * TheMain::ServerBuiltOn | ( | void | ) |
Returns our server built-on date.
| const char * TheMain::ServerVersion | ( | void | ) |
Returns our server version.
| void TheMain::Shutdown | ( | void | ) |
Allows anyone to tell us to shutdown.
|
private |
Shuts down our logger thread (do this last)
|
private |
Shuts down threads we've launched.
| twine & TheMain::SystemName | ( | void | ) |
Returns our system name.
|
private |
Test method to research RSA encryption/decryption.
|
private |
This is our config file.
|
private |
Our config file name.
|
private |
Our list of local databases:
|
private |
Global list of IOConn objects, this is the work that the system is doing.
|
private |
Is the current shutdown only for a re-config cycle.
|
private |
This is our RSA keypair that is used to encrypt/decrypt our documents.
|
private |
This vector tracks by name and reference all of the DLL files that we have loaded for any reason. When execution is finished, we will unload everything in this vector prior to exiting.
|
private |
This is our Adaptive Logger object.
|
private |
FIXME: use a real pool.
|
private |
This is our list of threads that we have launched directly. Since we launched 'em we're responsible for joining on 'em when they are all done.
|
private |
This keeps our protocol masters arranged by protocol type. It gives ready access to anyone who needs to send or receive a message via a specific protocol type.
|
private |
Should we shutdown now or not?
|
private |
|
private |
Our system name.
|
private |
The global ThreadList object.
|
private |
This is the current transaction id for our system.
|
private |
This is the mutex that protects access to the trans id.


- onCreate(Bundle) - Method in class com.orange.labs.sdk.activity.AuthActivity
-
- onErrorResponse(OrangeAPIException) - Method in interface com.orange.labs.sdk.OrangeListener.Error
-
Callback method that an error has been occurred with the
provided error code and optional user-readable message.
- onProgress(float) - Method in interface com.orange.labs.sdk.OrangeListener.Progress
-
Callback method to notify progress upload or download.
- onResponse(T) - Method in interface com.orange.labs.sdk.OrangeListener.Success
-
Called when a response is received.
- onSaveInstanceState(Bundle) - Method in class com.orange.labs.sdk.activity.AuthActivity
-
- OrangeAPIException - Exception in com.orange.labs.sdk.exception
-
- OrangeAPIException() - Constructor for exception com.orange.labs.sdk.exception.OrangeAPIException
-
- OrangeAPIException(Throwable) - Constructor for exception com.orange.labs.sdk.exception.OrangeAPIException
-
- OrangeAPIException(int, String, String, String) - Constructor for exception com.orange.labs.sdk.exception.OrangeAPIException
-
- OrangeCloudAPI<SESS_T extends Session> - Class in com.orange.labs.sdk
-
Location of the Orange Cloud API functions.
- OrangeCloudAPI(SESS_T) - Constructor for class com.orange.labs.sdk.OrangeCloudAPI
-
Create an instance of Orange Cloud Api
- OrangeCloudAPI.Entry - Class in com.orange.labs.sdk
-
A metadata entry that describes a file or folder.
- OrangeCloudAPI.Entry.Type - Enum in com.orange.labs.sdk
-
List of available item types
- OrangeCloudAPI.Metadata - Class in com.orange.labs.sdk
-
- OrangeListener - Class in com.orange.labs.sdk
-
- OrangeListener() - Constructor for class com.orange.labs.sdk.OrangeListener
-
- OrangeListener.Error - Interface in com.orange.labs.sdk
-
Callback interface for delivering error responses.
- OrangeListener.Progress - Interface in com.orange.labs.sdk
-
Callback interface for delivering error responses.
- OrangeListener.Success<T> - Interface in com.orange.labs.sdk
-
Callback interface for delivering responses Cloud Api.