Next Chapter | Previous Chapter | Contents | Index
NASM is a portable assembler, designed to be able to compile on any ANSI
C-supporting platform and produce output to run on a variety of Intel x86
operating systems. For this reason, it has a large number of available
output formats, selected using the
option on
the NASM command line. Each of these formats, along with its extensions to
the base NASM syntax, is detailed in this chapter.
As stated in section 2.1.1,
NASM chooses a default name for your output file based on the input file
name and the chosen output format. This will be generated by removing the
extension (
,
, or
whatever you like to use) from the input file name, and substituting an
extension defined by the output format. The extensions are given with each
format below.
bin
: Flat-Form Binary OutputThe
format does not produce object files:
it generates nothing in the output file except the code you wrote. Such
`pure binary' files are used by MS-DOS:
executables and
device drivers are pure
binary files. Pure binary output is also useful for operating system and
boot loader development.
The
format supports multiple section
names. For details of how NASM handles sections in the
format, see section
7.1.3.
Using the
format puts NASM by default into
16-bit mode (see section 6.1). In
order to use
to write 32-bit or 64-bit code,
such as an OS kernel, you need to explicitly issue the
or
directive.
has no default output file name extension:
instead, it leaves your file name as it is once the original extension has
been removed. Thus, the default is for NASM to assemble
into a binary file called
.
ORG
: Binary File Program OriginThe
format provides an additional
directive to the list given in chapter 6:
. The function of the
directive is to specify the origin address
which NASM will assume the program begins at when it is loaded into memory.
For example, the following code will generate the longword
:
org 0x100 dd label label:
Unlike the
directive provided by
MASM-compatible assemblers, which allows you to jump around in the object
file and overwrite code you have already generated, NASM's
does exactly what the directive says:
origin. Its sole function is to specify one offset which is added
to all internal address references within the section; it does not permit
any of the trickery that MASM's version does. See
section 12.1.3 for further
comments.
bin
Extensions to the SECTION
DirectiveThe
output format extends the
(or
)
directive to allow you to specify the alignment requirements of segments.
This is done by appending the
qualifier to
the end of the section-definition line. For example,
section .data align=16
switches to the section
and also
specifies that it must be aligned on a 16-byte boundary.
The parameter to
specifies how many low
bits of the section start address must be forced to zero. The alignment
value given may be any power of two.
bin
FormatThe
format allows the use of multiple
sections, of arbitrary names, besides the "known"
,
, and
names.
progbits
or
nobits
. Default is
progbits
(except .bss
,
which defaults to nobits
, of course).
align=
, or at an arbitrary
byte-granular position with start=
.
vstart=
.
follows=

or
vfollows=

as an alternative to specifying an explicit start address.
org
,
start
, vstart
, and
align=
are critical expressions. See
section 3.8. E.g.
align=(1 << ALIGN_SHIFT)
-
ALIGN_SHIFT
must be defined before it is used
here.
SECTION
directive is directed by default into the
.text
section.
ORG
statement is not given,
ORG 0
is used by default.
.bss
section will be placed after the
last progbits
section, unless
start=
, vstart=
,
follows=
, or vfollows=
has been specified.
section.<secname>.start
for each section,
which may be used in your code.
Map files can be generated in
format by
means of the
option. Map types of
(default),
,
,
, or
may be specified. Output may be directed
to
(default),
, or a specified file. E.g.
. No "user form" exists,
the square brackets must be used.
ith
: Intel Hex OutputThe
file format produces Intel hex-format
files. Just as the
format, this is a flat
memory image format with no support for relocation or linking. It is
usually used with ROM programmers and similar utilities.
All extensions supported by the
file
format is also supported by the
file format.
provides a default output file-name
extension of
.
srec
: Motorola S-Records OutputThe
file format produces Motorola
S-records files. Just as the
format, this is
a flat memory image format with no support for relocation or linking. It is
usually used with ROM programmers and similar utilities.
All extensions supported by the
file
format is also supported by the
file format.
provides a default output file-name
extension of
.
obj
: Microsoft OMF Object FilesThe
file format (NASM calls it
rather than
for
historical reasons) is the one produced by MASM and TASM, which is
typically fed to 16-bit DOS linkers to produce
files. It is also the format used by OS/2.
provides a default output file-name
extension of
.
is not exclusively a 16-bit format,
though: NASM has full support for the 32-bit extensions to the format. In
particular, 32-bit
format files are used by
Borland's Win32 compilers, instead of using Microsoft's newer
object file format.
The
format does not define any special
segment names: you can call your segments anything you like. Typical names
for segments in
format files are
,
and
.
If your source file contains code before specifying an explicit
directive, then NASM will invent its own
segment called
for you.
When you define a segment in an
file, NASM
defines the segment name as a symbol as well, so that you can access the
segment address of the segment. So, for example:
segment data dvar: dw 1234 segment code function: mov ax,data ; get segment address of data mov ds,ax ; and move it into DS inc word [dvar] ; now this reference will work ret
The
format also enables the use of the
and
operators,
so that you can write code which does things like
extern foo mov ax,seg foo ; get preferred segment of foo mov ds,ax mov ax,data ; a different segment mov es,ax mov ax,[ds:foo] ; this accesses `foo' mov [es:foo wrt data],bx ; so does this
obj
Extensions to the SEGMENT
DirectiveThe
output format extends the
(or
)
directive to allow you to specify various properties of the segment you are
defining. This is done by appending extra qualifiers to the end of the
segment-definition line. For example,
segment code private align=16
defines the segment
, but also declares it
to be a private segment, and requires that the portion of it described in
this code module must be aligned on a 16-byte boundary.
The available qualifiers are:
PRIVATE
, PUBLIC
,
COMMON
and STACK
specify the combination characteristics of the segment.
PRIVATE
segments do not get combined with any
others by the linker; PUBLIC
and
STACK
segments get concatenated together at link
time; and COMMON
segments all get overlaid on top
of each other rather than stuck end-to-end.
ALIGN
is used, as shown above, to specify how
many low bits of the segment start address must be forced to zero. The
alignment value given may be any power of two from 1 to 4096; in reality,
the only values supported are 1, 2, 4, 16, 256 and 4096, so if 8 is
specified it will be rounded up to 16, and 32, 64 and 128 will all be
rounded up to 256, and so on. Note that alignment to 4096-byte boundaries
is a PharLap extension to the format and may not be supported by all
linkers.
CLASS
can be used to specify the segment
class; this feature indicates to the linker that segments of the same class
should be placed near each other in the output file. The class name can be
any word, e.g. CLASS=CODE
.
OVERLAY
, like
CLASS
, is specified with an arbitrary word as an
argument, and provides overlay information to an overlay-capable linker.
USE16
or
USE32
, which has the effect of recording the
choice in the object file and also ensuring that NASM's default assembly
mode when assembling in that segment is 16-bit or 32-bit respectively.
FLAT
, which causes the default segment base for
anything in the segment to be the special group
FLAT
, and also defines the group if it is not
already defined.
obj
file format also allows segments to
be declared as having a pre-defined absolute segment address, although no
linkers are currently known to make sensible use of this feature;
nevertheless, NASM allows you to declare a segment such as
SEGMENT SCREEN ABSOLUTE=0xB800
if you need to.
The ABSOLUTE
and ALIGN
keywords are mutually exclusive.
NASM's default segment attributes are
,
, no class, no overlay, and
.
GROUP
: Defining Groups of SegmentsThe
format also allows segments to be
grouped, so that a single segment register can be used to refer to all the
segments in a group. NASM therefore supplies the
directive, whereby you can code
segment data ; some data segment bss ; some uninitialized data group dgroup data bss
which will define a group called
to
contain the segments
and
. Like
,
causes the group name to be defined as a
symbol, so that you can refer to a variable
in the
segment as
or as
, depending on which segment value
is currently in your segment register.
If you just refer to
, however, and
is declared in a segment which is part of a
group, then NASM will default to giving you the offset of
from the beginning of the group, not
the segment. Therefore
, also,
will return the group base rather than the segment base.
NASM will allow a segment to be part of more than one group, but will generate a warning if you do this. Variables declared in a segment which is part of more than one group will default to being relative to the first group that was defined to contain the segment.
A group does not have to contain any segments; you can still make
references to a group which does not contain
the variable you are referring to. OS/2, for example, defines the special
group
with no segments in it.
UPPERCASE
: Disabling Case Sensitivity in OutputAlthough NASM itself is case sensitive, some OMF linkers are not;
therefore it can be useful for NASM to output single-case object files. The
format-specific directive causes all
segment, group and symbol names that are written to the object file to be
forced to upper case just before being written. Within a source file, NASM
is still case-sensitive; but the object file can be written entirely in
upper case if desired.
is used alone on a line; it requires
no parameters.
IMPORT
: Importing DLL SymbolsThe
format-specific directive defines a
symbol to be imported from a DLL, for use if you are writing a DLL's import
library in NASM. You still need to declare the symbol as
as well as using the
directive.
The
directive takes two required
parameters, separated by white space, which are (respectively) the name of
the symbol you wish to import and the name of the library you wish to
import it from. For example:
import WSAStartup wsock32.dll
A third optional parameter gives the name by which the symbol is known in the library you are importing it from, in case this is not the same as the name you wish the symbol to be known by to your code once you have imported it. For example:
import asyncsel wsock32.dll WSAAsyncSelect
EXPORT
: Exporting DLL SymbolsThe
format-specific directive defines a
global symbol to be exported as a DLL symbol, for use if you are writing a
DLL in NASM. You still need to declare the symbol as
as well as using the
directive.
takes one required parameter, which is
the name of the symbol you wish to export, as it was defined in your source
file. An optional second parameter (separated by white space from the
first) gives the external name of the symbol: the name by which
you wish the symbol to be known to programs using the DLL. If this name is
the same as the internal name, you may leave the second parameter off.
Further parameters can be given to define attributes of the exported symbol. These parameters, like the second, are separated by white space. If further parameters are given, the external name must also be specified, even if it is the same as the internal name. The available attributes are:
resident
indicates that the exported name is
to be kept resident by the system loader. This is an optimisation for
frequently used symbols imported by name.
nodata
indicates that the exported symbol is
a function which does not make use of any initialized data.
parm=NNN
, where NNN
is an integer, sets the number of parameter words for the case in which the
symbol is a call gate between 32-bit and 16-bit segments.
For example:
export myfunc export myfunc TheRealMoreFormalLookingFunctionName export myfunc myfunc 1234 ; export by ordinal export myfunc myfunc resident parm=23 nodata
..start
: Defining the Program Entry Point
linkers require exactly one of the object
files being linked to define the program entry point, where execution will
begin when the program is run. If the object file that defines the entry
point is assembled using NASM, you specify the entry point by declaring the
special symbol
at the point where you
wish execution to begin.
obj
Extensions to the EXTERN
DirectiveIf you declare an external symbol with the directive
extern foo
then references such as
will give
you the offset of
from its preferred segment
base (as specified in whichever module
is
actually defined in). So to access the contents of
you will usually need to do something like
mov ax,seg foo ; get preferred segment base mov es,ax ; move it into ES mov ax,[es:foo] ; and use offset `foo' from it
This is a little unwieldy, particularly if you know that an external is
going to be accessible from a given segment or group, say
. So if
already contained
, you could simply code
mov ax,[foo wrt dgroup]
However, having to type this every time you want to access
can be a pain; so NASM allows you to declare
in the alternative form
extern foo:wrt dgroup
This form causes NASM to pretend that the preferred segment base of
is in fact
;
so the expression
will now return
, and the expression
is equivalent to
.
This default-
mechanism can be used to make
externals appear to be relative to any group or segment in your program. It
can also be applied to common variables: see
section 7.4.8.
obj
Extensions to the COMMON
DirectiveThe
format allows common variables to be
either near or far; NASM allows you to specify which your variables should
be by the use of the syntax
common nearvar 2:near ; `nearvar' is a near common common farvar 10:far ; and `farvar' is far
Far common variables may be greater in size than 64Kb, and so the OMF specification says that they are declared as a number of elements of a given size. So a 10-byte far common variable could be declared as ten one-byte elements, five two-byte elements, two five-byte elements or one ten-byte element.
Some
linkers require the element size, as
well as the variable size, to match when resolving common variables
declared in more than one module. Therefore NASM must allow you to specify
the element size on your far common variables. This is done by the
following syntax:
common c_5by2 10:far 5 ; two five-byte elements common c_2by5 10:far 2 ; five two-byte elements
If no element size is specified, the default is 1. Also, the
keyword is not required when an element size
is specified, since only far commons may have element sizes at all. So the
above declarations could equivalently be
common c_5by2 10:5 ; two five-byte elements common c_2by5 10:2 ; five two-byte elements
In addition to these extensions, the
directive in
also supports
default-
specification like
does (explained in
section 7.4.7). So you can also declare things
like
common foo 10:wrt dgroup common bar 16:far 2:wrt data common baz 24:wrt data:6
win32
: Microsoft Win32 Object FilesThe
output format generates Microsoft
Win32 object files, suitable for passing to Microsoft linkers such as
Visual C++. Note that Borland Win32 compilers do not use this format, but
use
instead (see
section 7.4).
provides a default output file-name
extension of
.
Note that although Microsoft say that Win32 object files follow the
(Common Object File Format) standard, the
object files produced by Microsoft Win32 compilers are not compatible with
COFF linkers such as DJGPP's, and vice versa. This is due to a difference
of opinion over the precise semantics of PC-relative relocations. To
produce COFF files suitable for DJGPP, use NASM's
output format; conversely, the
format does not produce object files that
Win32 linkers can generate correct output from. For similar reasons, the
COFF format used to be necessary on
Cygwin to link; it is now only present to be backward-compatible with
scripts that rely on this format.
win32
Extensions to the SECTION
DirectiveLike the
format,
allows you to specify additional
information on the
directive line, to
control the type and properties of sections you declare. Section types and
properties are generated automatically by NASM for the standard section
names
,
and
, but may still be overridden by these
qualifiers.
The available qualifiers are:
code
, or equivalently
text
, defines the section to be a code section.
This marks the section as readable and executable, but not writable, and
also indicates to the linker that the type of the section is code.
data
and bss
define
the section to be a data section, analogously to
code
. Data sections are marked as readable and
writable, but not executable. data
declares an
initialized data section, whereas bss
declares an
uninitialized data section.
rdata
declares an initialized data section
that is readable but not writable. Microsoft compilers use this section to
place constants in it.
info
defines the section to be an
informational section, which is not included in the executable file by the
linker, but may (for example) pass information to the linker. For
example, declaring an info
-type section called
.drectve
causes the linker to interpret the
contents of the section as command-line options.
align=
, used with a trailing number as in
obj
, gives the alignment requirements of the
section. The maximum you may specify is 64: the Win32 object file format
contains no means to request a greater section alignment than this. If
alignment is not explicitly specified, the defaults are 16-byte alignment
for code sections, 8-byte alignment for rdata sections and 4-byte alignment
for data (and BSS) sections. Informational sections get a default alignment
of 1 byte (no alignment), though the value does not matter.
The defaults assumed by NASM if you do not specify the above qualifiers are:
section .text code align=16 section .data data align=4 section .rdata rdata align=8 section .bss bss align=4
Any other section name is treated by default like
.
win32
: Safe Structured Exception HandlingAmong other improvements in Windows XP SP2 and Windows Server 2003
Microsoft has introduced concept of "safe structured exception handling."
General idea is to collect handlers' entry points in designated read-only
table and have alleged entry point verified against this table prior
exception control is passed to the handler. In order for an executable
module to be equipped with such "safe exception handler table," all object
modules on linker command line has to comply with certain criteria. If one
single module among them does not, then the table in question is omitted
and above mentioned run-time checks will not be performed for application
in question. Table omission is by default silent and therefore can be
easily overlooked. One can instruct linker to refuse to produce binary
without such table by passing
command
line option.
Without regard to this run-time check merits it's natural to expect NASM
to be capable of generating modules suitable for
linking. From developer's viewpoint the
problem is two-fold:
Former can be easily achieved with any NASM version by adding following line to source code:
<EMAIL_ADDRESS>equ 1
As of version 2.03 NASM adds this absolute symbol automatically. If it's not already present to be precise. I.e. if for whatever reason developer would choose to assign another value in source file, it would still be perfectly possible.
Registering custom exception handler on the other hand requires certain
"magic." As of version 2.03 additional directive is implemented,
, which instructs the assembler to produce
appropriately formatted input data for above mentioned "safe exception
handler table." Its typical use would be:
section .text extern _MessageBoxA@16 %if __NASM_VERSION_ID__ >= 0x02030000 safeseh handler ; register handler as "safe handler" %endif handler: push DWORD 1 ; MB_OKCANCEL push DWORD caption push DWORD text push DWORD 0 call _MessageBoxA@16 sub eax,1 ; incidentally suits as return value ; for exception handler ret global _main _main: push DWORD handler push DWORD [fs:0] mov DWORD [fs:0],esp ; engage exception handler xor eax,eax mov eax,DWORD[eax] ; cause exception pop DWORD [fs:0] ; disengage exception handler add esp,4 ret text: db 'OK to rethrow, CANCEL to generate core dump',0 caption:db 'SEGV',0 section .drectve info db '/defaultlib:user32.lib /defaultlib:msvcrt.lib '
As you might imagine, it's perfectly possible to produce .exe binary
with "safe exception handler table" and yet engage unregistered exception
handler. Indeed, handler is engaged by simply manipulating
location at run-time, something linker has
no power over, run-time that is. It should be explicitly mentioned that
such failure to register handler's entry point with
directive has undesired side effect at
run-time. If exception is raised and unregistered handler is to be
executed, the application is abruptly terminated without any notification
whatsoever. One can argue that system could at least have logged some kind
"non-safe exception handler in x.exe at address n" message in event log,
but no, literally no notification is provided and user is left with no clue
on what caused application failure.
Finally, all mentions of linker in this paragraph refer to Microsoft
linker version 7.x and later. Presence of
symbol and input data for "safe
exception handler table" causes no backward incompatibilities and "safeseh"
modules generated by NASM 2.03 and later can still be linked by earlier
versions or non-Microsoft linkers.
gnuwin32
: Cygwin Common Object File FormatThis used to generate a different VirtualSize header for BSS sections,
but nowadays it is identical to the
object
format (section 7.5) with the exception that it
uses the
filename extension by default.
win64
: Microsoft Win64 Object FilesThe
output format generates Microsoft
Win64 object files, which is nearly 100% identical to the
object format
(section 7.5) with the exception that it is
meant to target 64-bit code and the x86-64 platform altogether. This object
file is used exactly the same as the
object
format (section 7.5), in NASM, with regard to
this exception.
win64
: Writing Position-Independent CodeWhile
takes good care of RIP-relative
addressing, there is one aspect that is easy to overlook for a Win64
programmer: indirect references. Consider a switch dispatch table:
jmp qword [dsptch+rax*8] ... dsptch: dq case0 dq case1 ...
Even a novice Win64 assembler programmer will soon realize that the code is not 64-bit savvy. Most notably linker will refuse to link it with
'ADDR32' relocation to '.text' invalid without /LARGEADDRESSAWARE:NO
So [s]he will have to split jmp instruction as following:
lea rbx,[rel dsptch] jmp qword [rbx+rax*8]
What happens behind the scene is that effective address in
is encoded relative to instruction pointer,
or in perfectly position-independent manner. But this is only part of the
problem! Trouble is that in .dll context
relocations will make their way to the final module and might have to be
adjusted at .dll load time. To be specific when it can't be loaded at
preferred address. And when this occurs, pages with such relocations will
be rendered private to current process, which kind of undermines the idea
of sharing .dll. But no worry, it's trivial to fix:
lea rbx,[rel dsptch] add rbx,[rbx+rax*8] jmp rbx ... dsptch: dq case0-dsptch dq case1-dsptch ...
NASM version 2.03 and later provides another alternative,
operator, which returns offset
from base address of the current image, be it .exe or .dll module,
therefore the name. For those acquainted with PE-COFF format base address
denotes start of
structure. Here
is how to implement switch with these image-relative references:
lea rbx,[rel dsptch] mov eax,[rbx+rax*4] sub rbx,dsptch wrt ..imagebase add rbx,rax jmp rbx ... dsptch: dd case0 wrt ..imagebase dd case1 wrt ..imagebase
One can argue that the operator is redundant. Indeed, snippet before
last works just fine with any NASM version and is not even Windows
specific... The real reason for implementing
will become apparent in next
paragraph.
It should be noted that
is
defined as 32-bit operand only:
dd label wrt ..imagebase ; ok dq label wrt ..imagebase ; bad mov eax,label wrt ..imagebase ; ok mov rax,label wrt ..imagebase ; bad
win64
: Structured Exception HandlingStructured exception handing in Win64 is completely different matter
from Win32. Upon exception program counter value is noted, and
linker-generated table comprising start and end addresses of all the
functions [in given executable module] is traversed and compared to the
saved program counter. Thus so called
structure is identified. If it's not found, then offending subroutine is
assumed to be "leaf" and just mentioned lookup procedure is attempted for
its caller. In Win64 leaf function is such function that does not call any
other function nor modifies any Win64 non-volatile registers,
including stack pointer. The latter ensures that it's possible to identify
leaf function's caller by simply pulling the value from the top of the
stack.
While majority of subroutines written in assembler are not calling any
other function, requirement for non-volatile registers' immutability leaves
developer with not more than 7 registers and no stack frame, which is not
necessarily what [s]he counted with. Customarily one would meet the
requirement by saving non-volatile registers on stack and restoring them
upon return, so what can go wrong? If [and only if] an exception is raised
at run-time and no
structure is
associated with such "leaf" function, the stack unwind procedure will
expect to find caller's return address on the top of stack immediately
followed by its frame. Given that developer pushed caller's non-volatile
registers on stack, would the value on top point at some code segment or
even addressable space? Well, developer can attempt copying caller's return
address to the top of stack and this would actually work in some very
specific circumstances. But unless developer can guarantee that these
circumstances are always met, it's more appropriate to assume worst case
scenario, i.e. stack unwind procedure going berserk. Relevant question is
what happens then? Application is abruptly terminated without any
notification whatsoever. Just like in Win32 case, one can argue that system
could at least have logged "unwind procedure went berserk in x.exe at
address n" in event log, but no, no trace of failure is left.
Now, when we understand significance of the
structure, let's discuss what's in it
and/or how it's processed. First of all it is checked for presence of
reference to custom language-specific exception handler. If there is one,
then it's invoked. Depending on the return value, execution flow is resumed
(exception is said to be "handled"), or rest of
structure is processed as following.
Beside optional reference to custom handler, it carries information about
current callee's stack frame and where non-volatile registers are saved.
Information is detailed enough to be able to reconstruct contents of
caller's non-volatile registers upon call to current callee. And so
caller's context is reconstructed, and then unwind procedure is repeated,
i.e. another
structure is associated,
this time, with caller's instruction pointer, which is then checked for
presence of reference to language-specific handler, etc. The procedure is
recursively repeated till exception is handled. As last resort system
"handles" it by generating memory core dump and terminating the
application.
As for the moment of this writing NASM unfortunately does not facilitate generation of above mentioned detailed information about stack frame layout. But as of version 2.03 it implements building blocks for generating structures involved in stack unwinding. As simplest example, here is how to deploy custom exception handler for leaf function:
default rel section .text extern MessageBoxA handler: sub rsp,40 mov rcx,0 lea rdx,[text] lea r8,[caption] mov r9,1 ; MB_OKCANCEL call MessageBoxA sub eax,1 ; incidentally suits as return value ; for exception handler add rsp,40 ret global main main: xor rax,rax mov rax,QWORD[rax] ; cause exception ret main_end: text: db 'OK to rethrow, CANCEL to generate core dump',0 caption:db 'SEGV',0 section .pdata rdata align=4 dd main wrt ..imagebase dd main_end wrt ..imagebase dd xmain wrt ..imagebase section .xdata rdata align=8 xmain: db 9,0,0,0 dd handler wrt ..imagebase section .drectve info db '/defaultlib:user32.lib /defaultlib:msvcrt.lib '
What you see in
section is element of
the "table comprising start and end addresses of function" along with
reference to associated
structure.
And what you see in
section is
structure describing function with no
frame, but with designated exception handler. References are
required to be image-relative (which is the real reason for
implementing
operator). It should
be noted that
, as well as
, are optional in these two
segments' contexts, i.e. can be omitted. Latter means that all
32-bit references, not only above listed required ones, placed into these
two segments turn out image-relative. Why is it important to understand?
Developer is allowed to append handler-specific data to
structure, and if [s]he adds a 32-bit
reference, then [s]he will have to remember to adjust its value to obtain
the real pointer.
As already mentioned, in Win64 terms leaf function is one that does not
call any other function nor modifies any non-volatile register,
including stack pointer. But it's not uncommon that assembler programmer
plans to utilize every single register and sometimes even have variable
stack frame. Is there anything one can do with bare building blocks? I.e.
besides manually composing fully-fledged
structure, which would surely be
considered error-prone? Yes, there is. Recall that exception handler is
called first, before stack layout is analyzed. As it turned out, it's
perfectly possible to manipulate current callee's context in custom handler
in manner that permits further stack unwinding. General idea is that
handler would not actually "handle" the exception, but instead restore
callee's context, as it was at its entry point and thus mimic leaf
function. In other words, handler would simply undertake part of unwinding
procedure. Consider following example:
function: mov rax,rsp ; copy rsp to volatile register push r15 ; save non-volatile registers push rbx push rbp mov r11,rsp ; prepare variable stack frame sub r11,rcx and r11,-64 mov QWORD[r11],rax ; check for exceptions mov rsp,r11 ; allocate stack frame mov QWORD[rsp],rax ; save original rsp value magic_point: ... mov r11,QWORD[rsp] ; pull original rsp value mov rbp,QWORD[r11-24] mov rbx,QWORD[r11-16] mov r15,QWORD[r11-8] mov rsp,r11 ; destroy frame ret
The keyword is that up to
original
value remains in chosen volatile register and
no non-volatile register, except for
, is
modified. While past
remains constant till the very end of the
. In this case custom language-specific
exception handler would look like this:
EXCEPTION_DISPOSITION handler (EXCEPTION_RECORD *rec,ULONG64 frame, CONTEXT *context,DISPATCHER_CONTEXT *disp) { ULONG64 *rsp; if (context->Rip<(ULONG64)magic_point) rsp = (ULONG64 *)context->Rax; else { rsp = ((ULONG64 **)context->Rsp)[0]; context->Rbp = rsp[-3]; context->Rbx = rsp[-2]; context->R15 = rsp[-1]; } context->Rsp = (ULONG64)rsp; memcpy (disp->ContextRecord,context,sizeof(CONTEXT)); RtlVirtualUnwind(UNW_FLAG_NHANDLER,disp->ImageBase, dips->ControlPc,disp->FunctionEntry,disp->ContextRecord, &disp->HandlerData,&disp->EstablisherFrame,NULL); return ExceptionContinueSearch; }
As custom handler mimics leaf function, corresponding
structure does not have to contain
any information about stack frame and its layout.
coff
: Common Object File FormatThe
output type produces
object files suitable for linking with the
DJGPP linker.
provides a default output file-name
extension of
.
The
format supports the same extensions
to the
directive as
does, except that the
qualifier and the
section type are not supported.
macho32
and macho64
: Mach Object File FormatThe
and
output formts produces
object files suitable for linking with the
MacOS X linker.
is a synonym for
.
provides a default output file-name
extension of
.
elf32
, elf64
, elfx32
: Executable and Linkable Format Object FilesThe
,
and
output formats generate
(Executable and Linkable Format)
object files, as used by Linux as well as Unix System V, including Solaris
x86, UnixWare and SCO Unix.
provides a
default output file-name extension of
.
is a synonym for
.
The
format is used for the x32 ABI,
which is a 32-bit ABI with the CPU in 64-bit mode.
osabi
The ELF header specifies the application binary interface for the target
operating system (OSABI). This field can be set by using the
directive with the numeric value (0-255) of
the target system. If this directive is not used, the default value will be
"UNIX System V ABI" (0) which will work on most systems which support ELF.
elf
Extensions to the SECTION
DirectiveLike the
format,
allows you to specify additional information
on the
directive line, to control the
type and properties of sections you declare. Section types and properties
are generated automatically by NASM for the standard section names, but may
still be overridden by these qualifiers.
The available qualifiers are:
alloc
defines the section to be one which is
loaded into memory when the program is run.
noalloc
defines it to be one which is not, such
as an informational or comment section.
exec
defines the section to be one which
should have execute permission when the program is run.
noexec
defines it as one which should not.
write
defines the section to be one which
should be writable when the program is run.
nowrite
defines it as one which should not.
progbits
defines the section to be one with
explicit contents stored in the object file: an ordinary code or data
section, for example, nobits
defines the section
to be one with no explicit contents given, such as a BSS section.
align=
, used with a trailing number as in
obj
, gives the alignment requirements of the
section.
tls
defines the section to be one which
contains thread local variables.
The defaults assumed by NASM if you do not specify the above qualifiers are:
section .text progbits alloc exec nowrite align=16 section .rodata progbits alloc noexec nowrite align=4 section .lrodata progbits alloc noexec nowrite align=4 section .data progbits alloc noexec write align=4 section .ldata progbits alloc noexec write align=4 section .bss nobits alloc noexec write align=4 section .lbss nobits alloc noexec write align=4 section .tdata progbits alloc noexec write align=4 tls section .tbss nobits alloc noexec write align=4 tls section .comment progbits noalloc noexec nowrite align=1 section other progbits alloc noexec nowrite align=1
(Any section name other than those in the above table is treated by
default like
in the above table. Please
note that section names are case sensitive.)
elf
Special Symbols and WRT
The
specification contains enough features
to allow position-independent code (PIC) to be written, which makes ELF
shared libraries very flexible. However, it also means NASM has to be able
to generate a variety of ELF specific relocation types in ELF object files,
if it is to be an assembler which can write PIC.
Since
does not support segment-base
references, the
operator is not used for its
normal purpose; therefore NASM's
output
format makes use of
for a different purpose,
namely the PIC-specific relocation types.
defines five special symbols which you can
use as the right-hand side of the
operator to
obtain PIC relocation types. They are
,
,
,
and
. Their
functions are summarized here:
wrt ..gotpc
will end up giving the distance from
the beginning of the current section to the global offset table.
(_GLOBAL_OFFSET_TABLE_
is the standard symbol
name used to refer to the GOT.) So you would then need to add
$$
to the result to get the real address of the
GOT.
wrt ..gotoff
will give the distance from the
beginning of the GOT to the specified location, so that adding on the
address of the GOT would give the real address of the location you wanted.
wrt ..got
causes the linker to build an entry
in the GOT containing the address of the symbol, and the reference
gives the distance from the beginning of the GOT to the entry; so you can
add on the address of the GOT, load from the resulting address, and end up
with the address of the symbol.
wrt ..plt
causes the linker to build a procedure linkage table entry for the symbol,
and the reference gives the address of the PLT entry. You can only use this
in contexts which would generate a PC-relative relocation normally (i.e. as
the destination for CALL
or
JMP
), since ELF contains no relocation type to
refer to PLT entries absolutely.
wrt ..sym
causes NASM to write an ordinary relocation, but instead of making the
relocation relative to the start of the section and then adding on the
offset to the symbol, it will write a relocation record aimed directly at
the symbol in question. The distinction is a necessary one due to a
peculiarity of the dynamic linker.
A fuller explanation of how to use these relocation types to write shared libraries entirely in NASM is given in section 9.2.
elf
Special Symbols and WRT
wrt ..tlsie
causes the linker to build an entry
in the GOT containing the offset of the symbol within the TLS
block, so you can access the value of the symbol with code such as:
mov eax,[tid wrt ..tlsie] mov [gs:eax],ebx
wrt ..gottpoff
causes the linker to build
an entry in the GOT containing the offset of the symbol within the
TLS block, so you can access the value of the symbol with code such as:
mov rax,[rel tid wrt ..gottpoff] mov rcx,[fs:rax]
elf
Extensions to the GLOBAL
Directive
object files can contain more information
about a global symbol than just its address: they can contain the size of
the symbol and its type as well. These are not merely debugger
conveniences, but are actually necessary when the program being written is
a shared library. NASM therefore supports some extensions to the
directive, allowing you to specify these
features.
You can specify whether a global variable is a function or a data object
by suffixing the name with a colon and the word
or
.
(
is a synonym for
.) For example:
global hashlookup:function, hashtable:data
exports the global symbol
as a
function and
as a data object.
Optionally, you can control the ELF visibility of the symbol. Just add
one of the visibility keywords:
,
,
, or
. The default is
of course. For example, to make
hidden:
global hashlookup:function hidden
You can also specify the size of the data associated with the symbol, as a numeric expression (which may involve labels, and even forward references) after the type specifier. Like this:
global hashtable:data (hashtable.end - hashtable) hashtable: db this,that,theother ; some data here .end:
This makes NASM automatically calculate the length of the table and
place that information into the
symbol table.
Declaring the type and size of global symbols is necessary when writing shared library code. For more information, see section 9.2.4.
elf
Extensions to the COMMON
Directive
also allows you to specify alignment
requirements on common variables. This is done by putting a number (which
must be a power of two) after the name and size of the common variable,
separated (as usual) by a colon. For example, an array of doublewords would
benefit from 4-byte alignment:
common dwordarray 128:4
This declares the total size of the array to be 128 bytes, and requires that it be aligned on a 4-byte boundary.
The
specification doesn't provide
relocations for 8- and 16-bit values, but the GNU
linker adds these as an extension. NASM can
generate GNU-compatible relocations, to allow 16-bit code to be linked as
ELF using GNU
. If NASM is used with the
option, a warning is issued
when one of these relocations is generated.
ELF provides debug information in
and
formats. Line number information is
generated for all executable sections, but please note that only the
".text" section is executable by default.
aout
: Linux a.out
Object FilesThe
format generates
object files, in the form used by early
Linux systems (current Linux systems use ELF, see
section 7.10.) These differ from other
object files in that the magic number in
the first four bytes of the file is different; also, some implementations
of
, for example NetBSD's, support
position-independent code, which Linux's implementation does not.
provides a default output file-name
extension of
.
is a very simple object format. It
supports no special directives, no special symbols, no use of
or
, and no
extensions to any standard directives. It supports only the three standard
section names
,
and
.
aoutb
: NetBSD/FreeBSD/OpenBSD a.out
Object FilesThe
format generates
object files, in the form used by the
various free
clones,
,
and
. For simple object files, this object
format is exactly the same as
except for the
magic number in the first four bytes of the file. However, the
format supports position-independent code
in the same way as the
format, so you can use
it to write
shared libraries.
provides a default output file-name
extension of
.
supports no special directives, no
special symbols, and only the three standard section names
,
and
. However, it also supports the same use of
as
does, to
provide position-independent code relocation types. See
section 7.10.3 for full documentation of this
feature.
also supports the same extensions to the
directive as
does: see section 7.10.5 for documentation of
this.
as86
: Minix/Linux as86
Object FilesThe Minix/Linux 16-bit assembler
has its
own non-standard object file format. Although its companion linker
produces something close to ordinary
binaries as output, the object file format
used to communicate between
and
is not itself
.
NASM supports this format, just in case it is useful, as
.
provides a
default output file-name extension of
.
is a very simple object format (from the
NASM user's point of view). It supports no special directives, no use of
or
, and no
extensions to any standard directives. It supports only the three standard
section names
,
and
. The
only special symbol supported is
.
rdf
: Relocatable Dynamic Object File FormatThe
output format produces
object files.
(Relocatable Dynamic Object File Format) is
a home-grown object-file format, designed alongside NASM itself and
reflecting in its file format the internal structure of the assembler.
is not used by any well-known operating
systems. Those writing their own systems, however, may well wish to use
as their object format, on the grounds that
it is designed primarily for simplicity and contains very little
file-header bureaucracy.
The Unix NASM archive, and the DOS archive which includes sources, both
contain an
subdirectory holding a set of
RDOFF utilities: an RDF linker, an
static-library manager, an RDF file dump utility, and a program which will
load and execute an RDF executable under Linux.
supports only the standard section names
,
and
.
LIBRARY
Directive
contains a mechanism for an object file
to demand a given library to be linked to the module, either at load time
or run time. This is done by the
directive, which takes one argument which is the name of the module:
library mylib.rdl
MODULE
DirectiveSpecial
header record is used to store
the name of the module. It can be used, for example, by run-time loader to
perform dynamic linking.
directive takes
one argument which is the name of current module:
module mymodname
Note that when you statically link modules and tell linker to strip the
symbols from output file, all module names will be stripped too. To avoid
it, you should start module names with
, like:
module $kernel.core
rdf
Extensions to the GLOBAL
Directive
global symbols can contain additional
information needed by the static linker. You can mark a global symbol as
exported, thus telling the linker do not strip it from target executable or
library file. Like in
, you can also specify
whether an exported symbol is a procedure (function) or data object.
Suffixing the name with a colon and the word
you make the symbol exported:
global sys_open:export
To specify that exported symbol is a procedure (function), you add the
word
or
after declaration:
global sys_open:export proc
Similarly, to specify exported data object, add the word
or
to the
directive:
global kernel_ticks:export data
rdf
Extensions to the EXTERN
DirectiveBy default the
directive in
declares a "pure external" symbol (i.e. the
static linker will complain if such a symbol is not resolved). To declare
an "imported" symbol, which must be resolved later during a dynamic linking
phase,
offers an additional
modifier. As in
, you can also specify whether an imported
symbol is a procedure (function) or data object. For example:
library $libc extern _open:import extern _printf:import proc extern _errno:import data
Here the directive
is also included,
which gives the dynamic linker a hint as to where to find requested
symbols.
dbg
: Debugging FormatThe
output format is not built into NASM
in the default configuration. If you are building your own NASM executable
from the sources, you can define
in
or on the compiler command line,
and obtain the
output format.
The
format does not output an object file
as such; instead, it outputs a text file which contains a complete list of
all the transactions between the main body of NASM and the output-format
back end module. It is primarily intended to aid people who want to write
their own output drivers, so that they can get a clearer idea of the
various requests the main program makes of the output driver, and in what
order they happen.
For simple files, one can easily use the
format like this:
nasm -f dbg filename.asm
which will generate a diagnostic file called
. However, this will not work well on
files which were designed for a different object format, because each
object format defines its own macros (usually user-level forms of
directives), and those macros will not be defined in the
format. Therefore it can be useful to run
NASM twice, in order to do the preprocessing with the native object format
selected:
nasm -e -f rdf -o rdfprog.i rdfprog.asm nasm -a -f dbg rdfprog.i
This preprocesses
into
, keeping the
object format selected in order to make sure
RDF special directives are converted into primitive form correctly. Then
the preprocessed source is fed through the
format to generate the final diagnostic output.
This workaround will still typically not work for programs intended for
format, because the
and
directives have side effects of defining
the segment and group names as symbols;
will
not do this, so the program will not assemble. You will have to work around
that by defining the symbols yourself (using
, for example) if you really need to get a
trace of an
-specific source file.
accepts any section name and any
directives at all, and logs them all to its output file.


Gateway
BOT
15-Jun-19 01:32 AM
[dscrd-hush] <dukeleto> but yes, most messages will be small
[dscrd-hush] <dukeleto> like emails, chats, texts
[dscrd-hush] <Pixelised> Text, PDFs, images (memes) will be small.
[dscrd-hush] <dukeleto> imagine being able to send a meme pic via encrypted memo field!
[dscrd-hush] <dukeleto> that is one of my goals
[dscrd-hush] <dukeleto> 200KB is a lot of room for meme pics
[dscrd-hush] <dukeleto> small files take the least work, since they fit in 1 transaction
[dscrd-hush] <dukeleto> next level of complexity is medium files, which take up multiple transactions but still inside one block (but could straddle multiple blocks)
[dscrd-hush] <dukeleto> then finally files which take up multiple blocks to store
[dscrd-hush] <dukeleto> so it's like baby steps to the market, little steps to bigger steps
[dscrd-hush] <dukeleto> @Pixelised worst case is you break up your 1 logical file into multiple files on Hush blockchain, like "will part 1", "will part 2", etc..
[dscrd-hush] <Pixelised> Worst case would be having a zip archive across multiple 3.5 inch 1.44MB floppy disks.
[dscrd-hush] <dukeleto> I remember those days very well
[dscrd-hush] <dukeleto> My first Linux install was Slackware 3.3 which took about 12 floppy disks
Listed @graviex_net and @StexExchangeR on #gpu and #asic boards.
Remember to select them if you want to track their prices.
Few coins will get relisted as a result of this. $BTCP $VEIL $PIRL $HUSH
[dscrd-hush] <AkiraX> Nice. How muxh
[dscrd-hush] <AkiraX> And where
[dscrd-hush] <AkiraX> I night want to get some more
[dscrd-hush] <dukeleto> hush is back on whattomine.com, you need to select Graviex from the list of exchanges
[dscrd-hush] <AkiraX> I liked it better when I was mining in secret.
[dscrd-hush] <AkiraX> I don't recall. Is there any block halvings for hush
[dscrd-hush] <AkiraX> Every 210000 blocks
[dscrd-hush] <AkiraX> Found it
[dscrd-hush] <Pixelised> Yes,
[dscrd-hush] <Pixelised> Reward Halving: Every 4 years (same as Bitcoin)
[dscrd-hush] <AkiraX> When was the last halvings?
[dscrd-hush] <dukeleto> Hush has never had a halving, yet
[dscrd-hush] <dukeleto> block 340,000 on our new mainnet will be our halving
[dscrd-hush] <dukeleto> it would have been block 840,000 on our original chain
[dscrd-hush] <dukeleto> 210,000 for hush, you are right, it's 840,000 for BTC, who has a block time 4 times longer
[dscrd-hush] <dukeleto> it's every 4 years, for both
[dscrd-hush] <dukeleto> same as Zcash as well
[dscrd-hush] <dukeleto> Zcash halving will happen first, then Hush not too long after that. I think our halving is in November 2020 (because our genblock was November 2016), but i would need to write some code to get better estimates.
[dscrd-hush] <dukeleto> our hashrate has been changing a lot so it's hard to estimate when a block will happen over a long period of time, but late 2020 will be our 1st halving, total block reward will go from 12.5 to 6.25
[dscrd-hush] <dukeleto> so get in on all these good block rewards for the next 1-ish year
$HUSH is enabled again on the awesome @WhatToMine mining calculator!
Make sure to enable the @graviex_net exchange from the dropdown list too see Hush statistics.
The nethash must flow.


--- layout: page title: Training - educational courses permalink: /training/educational-courses/ main_image_path: main_image_caption: aside: true _options: layout: hidden: true image: width: 1200 height: 1200 resize_style: contain mime_type: image/jpeg _comments: ---
John can design and deliver financial management modules to fit into courses offered by educational insitutions in, for example, development studies. The content may be a mixture of existing or new material. The course can be developed to achieve current learning outcomes.
A module can be concentrated over a number of days or be delivered at individual sessions over a longer period. Materials can also be developed for e-learning and distance learning courses.
John has wide experience of teaching at university level on masters and diploma courses.
Contact John to discuss your own organisation's needs.


FDIL Interface
The Frames Desktop Integration Library (FDIL) is a small library
allowing the creation and manipulation of NewtonScript objects. Because
the objects the FDIL manipulates on are NewtonScript-compatible, they
can be exchanged with Newton devices using communications libraries
such as the CDIL.
The FDIL can create any type of NewtonScript object, including
virtual binary objects, and frames and arrays with circular references.
The FDIL, unlike NewtonScript, does not provide automatic garbage
collection.
About the FDIL Objects
The objects the FDIL manipulate mimic the NewtonScript
objects. There is a one-to-one correspondence between NewtonScript and
FDIL objects. There are a number of minor implementation details that
differ, however.


Copyright © 2005 W3C® (MIT, ERCIM, Keio), All Rights Reserved. W3C liability, trademark and document use rules apply.
This document describes some useful changes that could be incorporated into an XLink 1.1 Specification.
This section describes the status of this document at the time of its publication. Other documents may supersede this document. A list of current W3C publications and the latest revision of this technical report can be found in the W3C technical reports index at http://www.w3.org/TR/.
This document is a W3C Working Group Note, made available by the W3C XML Core Working Group as part of the XML Activity. The authors of this document are the XML Core Working Group participants.
This WG Note is being published for information purposes only. The Working Group does not plan to issue updates and therefore has no current plans or process by which to handle feedback.
Publication as a Working Group Note does not imply endorsement by the W3C Membership. This is a draft document and may be updated, replaced or obsoleted by other documents at any time. It is inappropriate to cite this document as other than work in progress.
Since its introduction as a Recommendation, [XLink] has been adopted by several markup vocabularies. However, the current trend to migrate from DTD-based validation to schema-based validation poses additional challenges that could hamper its continued adoption.
A few small changes could:
Make XLink easier to use.
Reduce its dependence on annotations provided by external grammars (XML DTDs or XML Schema, for example)
Increase interoperability by reducing the risk of markup errors or misinterpretations.
Make simple XLinks an application-level default.
In XLink 1.0, all simple links must be identified explicitly with
an xlink:type
attribute. When XLink 1.0 was developed, it
seemed reasonable to depend on DTD validation to provide this default
value when it was a burden to authors to enter it by hand. As XML use
has spread and new validation technologies have been developed, this
is no longer the case.
Rather than relying on an annotation to provide the simple link
type, it seems prudent to make this an application-level default. In
other words, any element with an xlink:href
attribute that
does not specify a link type should be treated as a simple link.
Reserve all attributes in the XLink namespace.
The current XLink 1.0 Recommendation defines several attributes in the XLink namespace. It seems prudent to explicitly reserve all other such attributes for future use. By a strict interpretation of the current specification, authors and other end-users have free latitude to use new attributes in the XLink namespace and this was never intended. Such use would create interoperability problems and should be prohibited.
Allow IRIs.
The current specification requires that URIs be used to identify some XLink properties, such as role and arc types. In the interest of forward compatibility, these requirements should be amended so that IRIs are also allowed.
Provide Sample XML Schema and RELAX NG Grammars.
The current specification provides a non-normative sample DTD. Given that XML Schema and RELAX NG are now widely deployed, it makes sense to provide equivalent, non-normative XML Schema and RELAX NG Grammars.
XLink is not without its critics and it's clearly the case that these changes do not address all of the criticisms that have been leveled at XLink. But these changes would make XLink more useful in the places where it is already being used and would make XLink practical in a variety of similar vocabularies.


This project developed by
Website and source code are open source code MIT License.
This system are controlled both by voice and mouse keyboard
develop by Kevin, Yue, Yang.


TensorFlow.js Image Classification
This webpage uses TensorFlow.js to train a machine learning model based on an array of images.


the and for e.g., with virus antiviral that against eye are have []. {background ocular (e.g., Artificial Virus conjunctivitis has viral from margin used drugs ophthalmic {border-style Influenza other px;} this which #ffffff;} Tears been drug may topical SARS-CoV- potential Eye can coronavirus drops effect treatment herpes patients surface their COVID- action activity effects human not repurposing simplex these viruses Antiviral The associated different use some through various [,,]. also influenza its shown Med. Virus, agents artificial infectious most such Agents HSV- Human Tear [,]. active after clinical during efficacy infection number px; severe substances tears {font-family (Vegetal Agent Antibiotic Coronavirus Disease Drops Drug Extract) For Ocular Porcine Preservative SARS-Cov- agent all any available commonly contained disease font-size hepatitis replication respiratory type vitro Acid Activity Aloe Antiseptic Broad Effect HSV-, Herpes RNA This Viral Viruses acid antimicrobial broad-spectrum but demonstrated diseases double; drops, high infections ingredients oil only particular, reported several should side sodium they transmission virucidal (Coronavirus) Action Although Anti-Allergic Buffering Clearly, Ginkgo Infect. Ophthalmic Rev. Some With [], acute addition, and/or antivirals article border-color border-width cell conjunctival could example, excipients generally global including inhibit interesting large medications medications, population possible preparations prevalence protein represent solid; specific tears, those thus very were widely {font-style {font-weight (COVID-) (See (in (which Anti-Glaucoma Anti-Inflammatory Clin. Considering Drugs Effects Epidemic HN, Herpetic Hosp. However, Japanese Med../jcm Oils Oral Overall, Replication Repurposing Res../j.antiviral... Text) Topical Treatment agent), allergic anti-glaucoma anti-inflammatory antibiotics approach ascorbic authors bold considered courier; currently described disinfectants dry due em; first formulations general glaucoma group here hyaluronic immunodeficiency importance include infections, into many might molecular note, oils ointments patients. potentially present preservatives, proteins pt;} recurrent reduction related sense, studies surface. symptoms syndrome types under viruses, viruses. vitamin was without


T-Mobile just told some customers that there was a data breach of their personal information. Here’s how to check if you’re affected.
by Aaron Holmes, Business Insider US- T-Mobile recently suffered a data breach where hackers gained access to some users’ personal information, the company confirmed Friday.
- Stolen data included users’ names, addresses, phone numbers, and plan details. No financial information or social security numbers were compromised.
- The company did not clarify the extent of the breach or when it happened.
- Visit Business Insider’s homepage for more stories.
T-Mobile recently suffered a data breach in which hackers accessed people’s personal information, the company confirmed Friday.
A malicious third party gained access to users’ account information, including names, addresses, phone numbers, account numbers, and the type of cell phone plan they’re on, according to T-Mobile’s announcement.
Financial information like credit card numbers were not compromised, and neither were social security number, the company said.
FCC rules require that T-Mobile notify people who were affected by the breach, but the company has not so far offered further details on when the breach happened, how it happened, who carried it out, or how many people are affected.
A T-Mobile spokesperson did not immediately respond to Business Insider’s request for comment.
Am I affected by the T-Mobile data breach?
Only T-Mobile customers were affected, so if you use a different carrier, you’re safe.
Beyond that, T-Mobile has not specified how many people were affected by the breach or what segments of users were affected, so there’s no easy way to rule yourself out.
T-Mobile said it will notify all affected users “shortly.” However, just because you didn’t receive a notification doesn’t mean you’re safe – T-Mobile notes that it may not have notified you if it doesn’t have your up-to-date contact information.
If you’re unsure whether you were affected, you can call 1-800-T-MOBILE to reach customer service.


Supersand Eagles crash out of Beach Soccer World Cup
by The Eagle OnlineNigeria’s Supersand Eagles have crashed out of the FIFA Beach World Cup following their 5-6 loss to Oman in Group D of the competition.
Oman jumped into a two-goal lead thanks to Eid Al Farsi’s left-footed, curling rocket into the far corner from distance and Jalal Al Sinani’s impressive scissor kick.
Emeka Ogbonna responded to the early letdown by scoring two goals and bringing the Super Sand Eagles level early in the second period.
However Oman just had too much for Nigeria as goals from Mushel Al Araimi, Al Farsi and Sami Al Bulushi had them 5-2 up at the end of the second period.
Ogbonna added another to complete his hat-trick before Adams Taiwo scored with a low drive into the bottom corner to bring the Super Sand Eagles back to within one.
Oman captain Khalid Al Oraimi scored once again to build a two-goal cushion before Godspower Igudia finished off a well-worked team move to score for Nigeria.
However it wasn’t enough and Oman were the ones letting out a sigh of relief and putting three crucial points on the board in Group D.
Nigeria would hope for a win in their final group game against Brazil on Tuesday, having lost two group games in the series.
Previous Post
Polaris Bank set to fund SMEs in Health Sector
Next Post
Joshua visits match venue for Ruiz rematch


New Islamic State chief 'a nobody': US official
WASHINGTON: The new leader of the Islamic State group is "a nobody" with little apparent reputation but the United States hopes he will be killed soon, a US official said on Wednesday (Nov 6).
The group last week announced Abu Ibrahim al-Hashimi al-Quraishi as its new leader after a US commando raid killed Abu Bakr al-Baghdadi, the chief of the ultra-violent movement.
READ: Islamic State names Baghdadi successor, vows revenge against US
A senior US official, speaking on condition of anonymity, said that monitoring of Islamic State social media indicates that even followers did not know much about Hashimi.
"That has become a major issue in, if you will, the ISIS social media world. This guy appears to be a nobody," the official told reporters.
"What little we know about him, we're not impressed. And if he's in Iraq or Syria, we don't think he's too long for the world anyway," he said.
The official declined to offer further details, including whether, like Baghdadi, Hashimi had been detained at some point by US forces.
President Donald Trump last week tweeted of the group's new leader that "we know exactly who he is," but few details have emerged about Hashimi.
Baghdadi, who led the Islamic State group since 2014, had become the world's most wanted person for the militants' grisly attacks both in the region and abroad.
The Islamic State group confirmed that the 48-year-old Iraqi died in the raid in Syria's northwestern Idlib province.


{%extends "nav_account.html"%} {%block title%}Meeting{%endblock%} {%block content%}
This meeting has finished.
{%else%} {%if meeting.is_open %} {%if meeting.is_started %}This meeting has started and is no longer allowing new attendees. If you were already connected and got disconnected, you may re-join the room.
{%else%}This meeting is open and you can now join.
{%endif%}{%if meeting.is_started%}Re-join{%else%}Join{%endif%} meeting
You can only be joined to the meeting from once device at a time. You can join from a different device by logging in on that device, or you can use this link. Be very careful when using this link, as it will automatically log you in to the meeting as yourself, so never share this link with somebody else!
{%else%}This meeting is not yet open. It will start on {{meeting.dateandtime|date:"Y-m-d H:i"}}, in {{meeting.dateandtime|timeuntil}}.
You will be able to enter the meeting room ahead of it starting at {{meeting.opentime|date:"Y-m-d H:i"}}, in {{meeting.opentime|timeuntil}}.
{%endif%} {%endif%} Return to list of meetings {%endblock%}


Manage.me is a state-of-art time management product which focuses on transforming the way you make your schedules and manage your time and tasks. We recoment using the app in compliance with S.M.A.R.T principles which we are inspired by. Our product aims at helping you to organise your tasks and allocate them in a more efficient way by providing a an agenda -view of all your allocated tasks and free time so that you can solve the puzzle of your schedule in a faster and easier intutive way. To know more about how our app works please visit these Help Docs to learn more.
Above is a video showing the application of these principles to Studies for Students.
S.M.A.R.T is a theory developed by the famous physcologist Edwin Locke in 1981. the abreveation S.M.A.R.T refres to an anlysis technique for goal setting as follows :-
Specific : what exactly will i be doing ? this should be clear while setting the Goal.
Measurable : there must be a min ammount of work decided to be finished , for example , in studies how will a person know that he has done the task properly - read , test , make notes.
Acceptable : One should know that is he pereapered to start working in that moment of time , a person should be in the suitable state to do the work. Half heaarted efforts never go fruitful.
Realistic : One has to set achievable realistic targets , setting unachivable gials give a psedo sense of faliure and results in demotivation.
Time bound : The goal should not be only target based , one must have an appropriate time limit on the task as well.
Lorem ipsum dolor sit amet, consectetur adipisicing elit. Iure aperiam consequatur quo.
Iure aperiam consequatur quo quis exercitationem reprehenderit dolor vel ducimus.
Aperiam consequatur quo quis exercitationem reprehenderit suscipit iste placeat.


Dashboard
User Profile
Table List
Maps
Upgrade to PRO
Stats
5
Notifications
Settings
Foot traffic
Head turns
General sentiment
Storefront Display 1


| About Dailyrotten |
|
Feedback
If you like this page, hate it, or would like to suggest changes,
<EMAIL_ADDRESS>is listening. This page
is experimental and somewhat different from what we usually offer, so please
do send your feedback.
Adding Stories
If you are a rotten newshound and you would like to suggest a story,
visit our submit page to
send us the URL. Stories that are accepted will have your name credited.
Viewership
On the first full day this page went live, 100,000 people visited this Rotten
News page. Of course that was the day after the WTC attacks, so that number is
somewhat distorted. Right now this page gets between 50,000 and 75,000 people
every day.
Linking
We encourage everyone to link to this page; if you like it, others probably
will as well.
 The victim managed to reach a hospital, but the penis could not be found. All because he got in the car. Never get in the car, kids.
|
|
Read article...
|
|
A tale of two papers
London Telegraph | Submitted by: Crazy Quagga
Both the London Telegraph and the Toronto Star take credit for uncovering the "smoking gun" evidence linking al Qaeda and Baghdad. This, uh, "coincidence" has been noted by many bloggers and alternative media sources on the Net. Highly suspicious.
|
|
Read article... and
This article...
|
|
London paper's front page image totally Photoshopped
The Memory Hole | Submitted by: Crazy Quagga
Brief article describing a pathetic photo manipulation job by a 4th rate hack at the London Evening Standard. The cover of the newspaper shows the typical earmarks of a lousy pic-rape: repeated elements, sloppy mushed background, and splicing different photos of the same event together. This is supposed to show thousands of people rejoicing at the fall of Saddam Hussein. Might have actually been two guys and a change of wardrobe.
|
|
Read article...
|
|
Columbine shooter gave warning signs
The Memory Hole | Submitted by: Crazy Quagga
A year before his killing spree at Columbine High, Eric Harris told mental health professionals that he was experiencing anger, depression, mood swings, disorganized thinking, suicidal and homicidal thoughts.  Arms, legs, and heads were tossed about as if a small child turned on a blender with no lid in the middle of the room. Some were burnt off, some torn, some eaten."
His teacher's comments? "Yours is a unique approach and your writing works in a gruesome way." It would have been more ironic if it said "Write what you know."
|
|
Read article...
|
|
Surprise: Lawn full of human bones
nettavisen.no | Submitted by: ole valaker
Last week, Sverre Knapstad bought 13 tons of filtered soil to landscape his garden. So far, he has found four human bones including a jawbone in the dirt mixture.
|
|
Read article...
|
|
Saddam trained for suicide
CNN | Submitted by: Captain Prozac
"Ousted Iraqi President Saddam Hussein has trained with explosive vests like those used by suicide bombers and could blow himself up rather than face capture by U.S. troops, an Iraqi opposition leader said Sunday." How hard can it possibly be?
|
|
Read article...
|
|
B.C. pot growers first to be certified organic
canada.com | Submitted by: Frigga
"'It's raising the credibility of medicinal marijuana as a legitimate medicine, as a safe medicine, as an alternative medicine to all the pharmaceuticals and other things that people tried that don't work,' Nash says."
|
|
Read article...
|
|
Arsonists permitted to join volunteer fire departments
Chicago Tribune | Submitted by: Reid Fleming
According to Illinois state law, convicted arsonists (and other felons) are ineligible to find work as professional firefighters. But they can be volunteers: "In May 2001, for instance, five white volunteers on the Brooklyn, Ill., Fire Department were arrested by local police and federal agents. The volunteers, all of whom lived in Missouri, were charged with setting arson fires in the predominantly black village. Under state law, the volunteers, if convicted, could continue to serve if the district's trustees allowed it."
|
|
Read article...
|
|
Charlie didn't ask for ID when I fought at La Choy and Chun King
CNN | Submitted by: Boat6float
"An ex-Marine who pretended to be a Vietnam War hero was sentenced to eight months in prison for altering military identification documents ... [H]e repeatedly wore the uniform in 2000 and 2001 at various speaking engagements where he would recount combat experiences in Vietnam." He also has a prior conviction for posing as a CIA officer.
|
|
Read article...
|
|
Man shoots girlfriend and her dad, sells gun for drugs
Chicago Tribune | Submitted by: Reid Fleming
After a long day of work, you deserve a cold beer. After shooting your girlfriend and her father, you need a lot more than beer, my friend. But what to do when you're broke? Considering the fact that you need to get rid of the evidence (e.g. the gun), why not sell it for drug money? Two birds with one stone.
|
|
Read article...
|
|
Bones disinterred in New Orleans graveyard
WKMG-TV 6 Orlando | Submitted by: Rio
Somebody broke into 10 or more crypts in Greenwood Cemetery and performed some minor redecorating. Evidently they moved the skull from each tomb and placed it atop the structure. Meddling kids, perhaps.
|
|
Read article...
|
|
Enquirer admits it made up shit
Deseret News | Submitted by: Reid Fleming
"The family of Elizabeth Smart and the National Enquirer have reached a settlement that retracts salacious comments published by the tabloid last summer. Part of the settlement includes a rare apology to the family and admission it printed false information about Smart family members." Evidently the Smarts were upset over an article in the July 2 issue entitled "Utah Cops: Secret Diary Exposes Family Sex Ring." In the piece, an unnamed law enforcement official was supposed to have said, "There is a bizarre gay twist to this story." How very intriguing.
|
|
Read article...
|
|
Molotov cocktails found on school playground
WKMG-TV 6 Orlando | Submitted by: Rio
Three molotov cocktails were found Monday on a Casselberry Elementary playground, according to Local 6 News. The bottles containing an unknown flammable liquid were reportedly found by several students at the school located at 4195 South Highway 17-92. Casselberry police recovered the bottles and are conducting an investigation into where they came from.
|
|
Read article...
|
|
|
|
|


Please wait...
Welcome to The Only Right Chat!
You must be logged in to use this app.
Click this button to invite people to chat!
click this button. You can use advanced text formatting.
Do you really want to remove this conversation? All messages will be permanently lost!
star Administrator
message Member
block Muted
Kicked user will be not longer able to read and write in this conversation.
Nick: edit
Avatar: cloud_uploadclear
E-mail address: edit
For security reasons, you must enter your password
This will delete your account permanently!


Issue 6 - Season 1
←
Prev
→
Next
∞
Overview
Help
dating dysphoric
how to drain the brachial artery
,
creation myth #18
men and women in the town
self on the first date
species dysphoria
the tap water tastes of chlorine
unhelpable
,
love poem with a line from frank stanford


WikiBrowser Licensed under the MIT License. See the project on GitHub
Well done! You completed the challenge with just clicks.


Toy Story
In a world where toys pretend to be lifeless in the presence of humans, Woody, a pullstring cowboy doll, is the leader of a group of toys that are owned by a boy named Andy Davis.
Duration: 81 minutes
Animation, Adventure, Comedy
Avatar
A marine on an alien planet.
Duration: 162 minutes
Action, Adventure, Fantasy
Spirited Away
During her family's move to the suburbs, a sullen 10-year-old girl wanders into a world ruled by gods, witches, and spirits, and where humans are changed into beasts.
Duration: 125 minutes
Anime, Animation, Adventure, Family
School of Rock
Rock musician becomes high school music teacher.
Duration: 108 minutes
Comedy, Music
Midnight in Paris
A screenwriter confronts his relationship by travelling back in time at midnight.
Duration: 94 minutes
Comedy, Fantasy, Romance
Ratatouille
A rat who can cook makes an alliance with a young kitchen worker.
Duration: 111 minutes
Animation, Comedy, Family
Hunger Games
A girl must survive the oppressive regime's death games.
Duration: 142 minutes
Adventure, Drama, Sci-Fi
Mononoke Hime
A warrior princess raised by wolves, a cursed wanderer, and industrious mayor fight for future of a sacred forest.
Duration: 130 minutes
Anime, Animation, Action, Adventure, Fantasy
Better Call Saul
A former scam artist tries to make it as a lawyer, all while dealing with his paranoid brother always putting him down, the local Mexican cartel, and his own inability to let go of his past.
Duration: 46 minutes | Episodes: 20 | Ongoing
Crime, Drama
Cowboy Bebop
A ragtag team of bounty hunters travelling through space.
Duration: 24 minutes | Episodes: 26
Animation, Anime, Action, Adventure, Comedy, Drama, Sci-Fi, Space
Full Metal Panic? Fumoffu
Its back-to-school mayhem with Kaname Chidori and her war-freak classmate Sousuke Sagara as they encounter more misadventures in and out of Jindai High School.
Duration: 24 minutes | Episodes: 12
Animation, Anime, Action, Comedy, School
Ergo Proxy
An inspector and framed immigrant work to unravel the mystery of androids gone rogue in a dystopian future.
Duration: 25 minutes | Episodes: 23
Animation, Anime, Mystery, Psychological, Sci-Fi
Ghost in the Shell: Stand Alone Complex
Motoko Kusanagi and her team at Section 9 solve and deal with criminal activity in a future where law-breakers are making full use of the power available in a technologically advanced future.
Duration: 25 minutes | Episodes: 26
Animation, Anime, Action, Mecha, Military, Police, Sci-Fi, Seinen
Nichijou
Nichijou primarily focuses on the daily antics of a trio of childhood friends—high school girls Mio Naganohara, Yuuko Aioi and Mai Minakami—whose stories soon intertwine with the young genius Hakase Shinonome, her robot caretaker Nano, and their talking cat Sakamoto.
Duration: 23 minutes | Episodes: 26
Animation, Anime, Comedy, School, Slice of Life


2023 Hugo Awards
Best Fan Writer Finalist
Reading Pack
Cover Artist: Lao Zao (醪糟)
Special Thanks to: ErsatzCulture
Arthur Liu is a Chinese SFF fan writer and author. As a software engineer living in Beijing, he co-founded the
Chinese Science Fiction Database (CSFDB)
with Sanfeng Zhang
in 2020. He publishes fiction as Yang Feng (杨枫, a name taken from a self-reflective character from his own stories, and not to be confused with the other nominee of that name in the Best Editor[Short Form] category) and fan writings as HeavenDuke(天爵).
He was the editor of the clubzine of the Tsinghua University Science Fiction Association of Students,
with two special issues Kingdom Anonymous and E=mc³: Side-Wonders of Science Studies professionally published.
Translation of his stories have appeared in Clarkesworld and Future Science Fiction Digest,
with a reprint of "The Life Cycle of a Cyber-Bar" to appear in The Big Book of Cyberpunk, due from Vintage/Penguin Random House in September 2023.
He dreams of becoming a web crawler.


15 November 2000
Disease Outbreak Reported
As of 13 November, the Ugandan Ministry of Health has reported 1 new laboratory confirmed case. No new deaths have been reported as of 14 November.
The Ugandan Ministry of Health has reported cumulative figures for Gulu district of 321 cases, including 104 deaths.


Conveniently take and process payments
GOV.UK Pay allows the public and businesses to pay government in a consistent way. It also gives service teams the tools they need to reconcile these payments and deal with any potential queries.
Try it out- create an account
- make some test payments
- test the features of the GOV.UK Pay admin tool
Last updated: two weeks ago


This allows applications to access system settings.
#include <fogo/Light.hpp>
#include <fogo/FSys.hpp>
Definition at line 30 of file FSys.hpp.
|
|
static int | init () |
| | Initialize access to system settings.
|
| |
|
static int | set_default () |
| | Set system settings to the default values.
|
| |
|
static sys_eeprom_t | sys () |
| | Return a structure containing all system settings.
|
| |
|
static float | brightness (void) |
| | Return the default brightness setting (0 to 100)
|
| |
|
static float | brightness_high (void) |
| | Return the high brightness setting (0 to 100)
|
| |
|
static float | brightness_med (void) |
| | Return the med brightness setting (0 to 100)
|
| |
|
static float | brightness_low (void) |
| | Return the low brightness setting (0 to 100)
|
| |
|
static u16 | long_press (void) |
| | Return the duration of a long press in ms.
|
| |
|
static u16 | short_press (void) |
| | Return the duration of a long press in ms.
|
| |
|
static u16 | morse_delay (void) |
| | Return the time in ms that the morse input waits for a letter.
|
| |
|
static u16 | backlight_time (void) |
| | Read the backlight time.
|
| |
|
static void | set_brightness (float value) |
| | Set the default brightness setting.
|
| |
|
static void | set_brightness_high (float value) |
| | Set high brightness setting (0 to 100)
|
| |
|
static void | set_brightness_med (float value) |
| | Set med brightness setting (0 to 100)
|
| |
|
static void | set_brightness_low (float value) |
| | Set low brightness setting (0 to 100)
|
| |
|
static void | set_short_press (u16 value) |
| | Set short press duration in ms.
|
| |
|
static void | set_long_press (u16 value) |
| | Set long press duration in ms.
|
| |
|
static void | set_morse_delay (u16 value) |
| | Set the morse input delay in ms.
|
| |
| static void | tilt_set_enable (bool v=true) |
| | Set the tilt enable function on the flashlight. More...
|
| |
|
static bool | tilt_enable () |
| | The current value of the tilt enable.
|
| |
|
static void | backlight_set_time (u16 value) |
| | Set the backlight on time.
|
| |
|
static void | set_units (enum sys_units value) |
| | Set system units.
|
| |
| static enum sys_units | units () |
| | Returns current system units setting. More...
|
| |
|
static sn_t | serial_no () |
| | Return the serial number of the device.
|
| |
|
static const char * | activity_dir () |
| | Activity Directory.
|
| |
|
static const char * | notifications_dir () |
| | Notifications Directory.
|
| |
|
static const char * | contacts_dir () |
| | Contacts Directory.
|
| |
|
static const char * | messages_dir () |
| | Messages Directory.
|
| |
|
static const char * | maps_dir () |
| | Maps Directory.
|
| |
|
static const char * | loc_dir () |
| | Location Directory.
|
| |
| static int | powerdown (u32 delay=0, u32 wakeup=0) |
| | Turn the device off. More...
|
| |
| static void | launch (const char *path, const char *args=0) |
| | Launch an app (current app exits) More...
|
| |
| static void | save_settings (void) |
| | Save system settings. More...
|
| |


First let's define a random matrix
A = rand(1:4,3,3)
Define a vector of ones
x = fill(1.0, (3))
Notice that $A$ has type Array{Int64,2} but $x$ has type Array{Float64,1}. Julia defines the aliases Vector{Type}=Array{Type,1} and Matrix{Type}=Array{Type,2}.
Many of the basic operations are the same as in other languages
b = A*x
As in other languages A'
is the conjugate transpose
A'
and we can get the transpose with
transpose(A)
Julia allows us to write this without *
A'A
The problem $Ax=b$ for square $A$ is solved by the \ function.
A\b
Matrix structure is very important in linear algebra. To see how important it is, let's work with a larger linear system. Use the LinearAlgebra standard package to get access to structured matrices:
using LinearAlgebra
n = 1000
A = randn(n,n);
Julia can often infer special matrix structure
Asym = A + A'
issymmetric(Asym)
but sometimes floating point error might get in the way.
Asym_noisy = copy(Asym)
Asym_noisy[1,2] += 5eps()
issymmetric(Asym_noisy)
Luckily we can declare structure explicitly with, for example, Diagonal
, Triangular
, Symmetric
, Hermitian
, Tridiagonal
and SymTridiagonal
.
Asym_explicit = Symmetric(Asym_noisy);
Let's compare how long it takes Julia to compute the eigenvalues of Asym
, Asym_noisy
, and Asym_explicit
@time eigvals(Asym);
@time eigvals(Asym_noisy);
@time eigvals(Asym_explicit);
In this example, using Symmetric()
on Asym_noisy
made our calculations about 5x
more efficient :)
Using the Tridiagonal
and SymTridiagonal
types to store tridiagonal matrices makes it possible to work with potentially very large tridiagonal problems. The following problem would not be possible to solve on a laptop if the matrix had to be stored as a (dense) Matrix
type.
n = 1_000_000;
A = SymTridiagonal(randn(n), randn(n-1));
@time eigmax(A)


get latency until relevant AOI is saccade target Syntax: latency =calcLatencyRelAOISac( eyePos, aoiCenter, maxDist, AOIsOfInterest ) Inputs: eyePos: vector of complex (x+i*y) coordinates. -1-i1 to identify missing data. They are in range [ 0 ,1 ] aoiCenter: coordinates of AOI in image scale, returned by 'returnAOICenters.m' maxDist: returned by 'returnAOICenters.m' AOIsOfInterest: index of AOIs which we are interested in Outputs: latency: value between 0 and length of eye track,
0001 % get latency until relevant AOI is saccade target 0002 % 0003 % Syntax: latency =calcLatencyRelAOISac( eyePos, aoiCenter, maxDist, AOIsOfInterest ) 0004 % 0005 % Inputs: 0006 % eyePos: vector of complex (x+i*y) coordinates. -1-i1 to identify 0007 % missing data. They are in range [ 0 ,1 ] 0008 % aoiCenter: coordinates of AOI in image scale, returned by 'returnAOICenters.m' 0009 % maxDist: returned by 'returnAOICenters.m' 0010 % AOIsOfInterest: index of AOIs which we are interested in 0011 % 0012 % Outputs: 0013 % latency: value between 0 and length of eye track, 0014 % 0015 0016 function latency =calcLatencyRelAOISacDist( sacStruct, aoiCenter, maxDist, AOIsOfInterest ) 0017 0018 0019 0020 saccadeVec = sacStruct.saccadeVec; 0021 % % startSacPos = sacStruct.startSacPos; 0022 endSacPos = sacStruct.endSacPos; 0023 0024 numFixation = size(endSacPos,2); 0025 numSamples = length( saccadeVec ); 0026 latency = numSamples; 0027 0028 for i1 = 1:numFixation 0029 dist = calc2Dist( endSacPos(:,i1), aoiCenter); % 2-norm 0030 [minDist minIdx] = min( dist); 0031 if minDist < maxDist && sum(minIdx == AOIsOfInterest) 0032 latency = find( saccadeVec == i1 ); 0033 latency = latency(end); %/numSamples; % look at end of saccade 0034 break; 0035 end 0036 0037 end 0038 0039 0040 0041 0042


Motivation 21/08/17
- How does life look through the 'pleasure, passion and purpose' lens? There are three main forms of happiness: The first is Pleasure, which has a reputation for being "rock-star" form of happiness as it is based on chasing the next high. This form of happiness is highly unstable as it is hard to maintain. Then there’s Passion/Flow, which is a blend of peak performance and peak engagement. Also known as “being in the zone”, a state of focused attention that a lot of athletes experience. In this instance, time seems to fly by and and is regarded as a much more sustainable form of happiness than pleasure is, as it's not as easy to become accustomed to it. And finally, Higher Purpose. This is the notion of being part of something bigger than yourself. This form of happiness is very resilient and the most sustainable of the three. It is suggested that we naturally seek Pleasure but we should instead be looking into Higher Purpose, then Passion and lastly Pleasure.
- What are your core values? I value my family, my close friends, honesty, and being able to have a laugh.
- What do you stand for? Looking out for one another, and helping those in need. Never put someone down or make them feel uncomfortable.
- How did you find the resilience ideas and meditation exercise? I like the idea that the ocean metaphor for happiness can be applied to resilience, and this that happiness/resilience is a deep ocean, the surface can be choppy but it always calm deep down. The meditation exercise was interesting as it got you to recount both a time of success and failure. It got you to recognise the emotions but not to react to them, which is a hard thing to do when you are recounting such events. I found this to be quite calming.
From the 'discovering values and higher purpose' exercise,


A simplified 2D predator-prey simulatoion.
This assignment employed standard Object Oriented Principles, such as inheritance, abstraction and polymorphism.
Both the Human and Zombie classes inherited from the parent Organism class, and had to follow guidelines regarding movement, feeding, and reproduction. They were upcast or downcast depending on the specificity of the method.
Ideally, both Human and Zombie populations should never experience an extinction event, mimicking the ebb and flow of a natural biological environment.
This project was one of the most satisfying and rewarding applications to watch run upon completion.
C++


Defines the number of records in the grid when to start virtualization
Number, default = 150
Virtualization is the process when only records in the current scroll window are added to the actual DOM tree. This approach
allows grid to have millions of records and still be snappy. So, if grid has less then 150 records, all of them will be available
in the DOM, however, if more, only the records that are in the view.
You should not normally change this property.


First Name is required
Last Name is required
Valid email is required
Password is required
Confirm password is required


Sharding-JDBC-Server
Introduction
Sharding-JDBC-Server is the MySQL protocol agent based on Sharding-JDBC, and more friendly for management and debugging. You can use any clients compatible with MySQL protocol, e.g. MySQL Command Client, MySQL Workbench to connect to Sharding-JDBC-Server to query and modify data.
In brief, Sharding-JDBC-Server is a standard MySQL (Other databases might be included in future) that also supports Sharding, Read-write-splitting, and orchestration and is also like the management interface for all back-end MySQL Sharding. In fact, it is the control node, the management node, and the routing node.
Sharding-JDBC-Server is suitable for uses to manage and debug, and can be connected easily by various MySQL clients, and Sharding-JDBC is more suitable for online programs for it reduces the cost of secondary transmit.
Usage
- Download the latest version of Sharding-JDBC-Server from https://github.com/shardingjdbc/sharding-jdbc-doc/raw/master/dist/sharding-proxy-2.1.0-SNAPSHOT-assembly-v1.tar.gz
- Modify the conf/sharding-config.yaml file after decompression, and configure the sharding rule. Refer to The YAML configuration in Sharding-JDBC。
- Run bin/start.sh in Linux, or bin/start.bat in Windows to start Sharding-JDBC-Server.
- Connect to it by means of any client tools, e.g. mysql -u root -h <IP_ADDRESS> -P3307
Notices
- The default port of Sharding-JDBC-Server is 3307, and can be changed by passing the port parameter to the startup script, e.g. bin/start.sh 3308.
- There is only one logical data source in Sharding-JDBC-Server, named
sharding-db
.
- Currently, Sharding-JDBC-Server does not support authorization, therefore you can login with any username and password at startup.


For full functionality of this site, it is necessary to enable JavaScript. You can find a step-by-step instruction at
enable-javascript.net
to enable JavaScript in your web browser.
How to use? - Free Generator to QR Code and Barcode
Home
QR Code
Barcode
About
How to use?
Contact Us
How to use:
How to generate a QR Code?
How to generate a Barcode?


|
QuantLib: a free/open-source library for quantitative finance
Fully annotated sources - version 1.30
|
Quote for a forward starting swap. More...
#include <ql/quotes/forwardswapquote.hpp>
Public Member Functions | |
| ForwardSwapQuote (ext::shared_ptr< SwapIndex > swapIndex, Handle< Quote > spread, const Period &fwdStart) | |
Quote interface | |
| Real | value () const override |
| returns the current value More... | |
| bool | isValid () const override |
| returns true if the Quote holds a valid value More... | |
| Public Member Functions inherited from Quote | |
| ~Quote () override=default | |
| virtual Real | value () const =0 |
| returns the current value More... | |
| virtual bool | isValid () const =0 |
| returns true if the Quote holds a valid value More... | |
| Public Member Functions inherited from Observable | |
| Observable () | |
| Observable (const Observable &) | |
| Observable & | operator= (const Observable &) |
| virtual | ~Observable ()=default |
| void | notifyObservers () |
| Public Member Functions inherited from LazyObject | |
| ~LazyObject () override=default | |
| void | forwardFirstNotificationOnly () |
| void | alwaysForwardNotifications () |
| void | recalculate () |
| void | freeze () |
| void | unfreeze () |
| Public Member Functions inherited from Observer | |
| Observer ()=default | |
| Observer (const Observer &) | |
| Observer & | operator= (const Observer &) |
| virtual | ~Observer () |
| std::pair< iterator, bool > | registerWith (const ext::shared_ptr< Observable > &) |
| void | registerWithObservables (const ext::shared_ptr< Observer > &) |
| Size | unregisterWith (const ext::shared_ptr< Observable > &) |
| void | unregisterWithAll () |
| virtual void | update ()=0 |
| virtual void | deepUpdate () |
Observer interface | |
| ext::shared_ptr< SwapIndex > | swapIndex_ |
| Handle< Quote > | spread_ |
| Period | fwdStart_ |
| Date | evaluationDate_ |
| Date | valueDate_ |
| Date | startDate_ |
| Date | fixingDate_ |
| ext::shared_ptr< VanillaSwap > | swap_ |
| Rate | result_ |
| void | update () override |
| const Date & | valueDate () const |
| const Date & | startDate () const |
| const Date & | fixingDate () const |
| void | initializeDates () |
| void | performCalculations () const override |
Additional Inherited Members | |
| Public Types inherited from Observer | |
| typedef set_type::iterator | iterator |
| Protected Member Functions inherited from LazyObject | |
| virtual void | calculate () const |
| Protected Attributes inherited from LazyObject | |
| bool | calculated_ = false |
| bool | frozen_ = false |
| bool | alwaysForward_ = true |
Quote for a forward starting swap.
Definition at line 35 of file forwardswapquote.hpp.
| ForwardSwapQuote | ( | ext::shared_ptr< SwapIndex > | swapIndex, |
| Handle< Quote > | spread, | ||
| const Period & | fwdStart | ||
| ) |
|
overridevirtual |
returns the current value
Implements Quote.
Definition at line 72 of file forwardswapquote.cpp.
|
overridevirtual |
returns true if the Quote holds a valid value
Implements Quote.
Definition at line 77 of file forwardswapquote.cpp.
|
overridevirtual |
This method must be implemented in derived classes. An instance of Observer does not call this method directly: instead, it will be called by the observables the instance registered with when they need to notify any changes.
Reimplemented from LazyObject.
Definition at line 49 of file forwardswapquote.cpp.
| const Date & valueDate | ( | ) | const |
| const Date & startDate | ( | ) | const |
| const Date & fixingDate | ( | ) | const |
|
protected |
|
overrideprotectedvirtual |
This method must implement any calculations which must be (re)done in order to calculate the desired results.
Implements LazyObject.
Definition at line 88 of file forwardswapquote.cpp.
|
protected |
Definition at line 57 of file forwardswapquote.hpp.
Definition at line 58 of file forwardswapquote.hpp.
|
protected |
Definition at line 59 of file forwardswapquote.hpp.
|
protected |
Definition at line 61 of file forwardswapquote.hpp.
|
protected |
Definition at line 61 of file forwardswapquote.hpp.
|
protected |
Definition at line 61 of file forwardswapquote.hpp.
|
protected |
Definition at line 61 of file forwardswapquote.hpp.
|
protected |
Definition at line 62 of file forwardswapquote.hpp.
|
mutableprotected |
Definition at line 64 of file forwardswapquote.hpp.


Climate change protests staged across the globe
The protests come just days before officials gather in Madrid for talks on tackling climate change.
Australians affected by recent devastating wildfires in the country have joined young environmentalists kicking off a global protest demanding that governments act against climate change.
The “global day of action” involves rallies in hundreds of cities around the world.
It comes days before officials gather on Monday in Madrid for talks on tackling climate change.
Janet Reynolds, who joined a protest in Sydney, said she had lost everything in an “inferno, an absolute firestorm that raced through my property”.
Speaking outside the local offices of Prime Minister Scott Morrison’s Liberal Party, student Daisy Jeffrey said: “People have lost their homes, people have lost their lives. We have to ask: How far does this have to go before our government finally takes action?”
Further rallies were taking places in cities worldwide, including Washington, London, Berlin and Madrid.
Swedish teenage activist Greta Thunberg, who is travelling across the Atlantic by sailboat to attend the climate talks next week, sent a message of support to protesters.
“Everyone’s needed. Everyone’s welcome. Join us,” she said on Twitter.
The package was blocked Friday by Germany’s upper house, which represents the country’s 16 states.
In South Africa, a few dozen people holding signs saying “Not Cool” and “Stop Pollution Now” protested outside the Johannesburg Stock Exchange.
One protester lay on the ground faking death, holding a sign saying “Black Friday, Reason to Grieve.”
“The reality is that we have a climate change emergency,” said protest organiser Elana Azrai. She noted water shortages in parts of the country amid a drought in southern Africa.
Elsewhere, officials have raised the alarm over unusually severe rainfall in East Africa and a pair of cyclones that ripped into Mozambique within weeks of each other earlier this year.
Scores of young Nigerians marched in downtown Lagos displaying messages such as “There is no planet B” and “Stop Denying the Earth is Dying” as passing vehicles slowed and honked horns in support.