text stringlengths 1 1.05M |
|---|
; A044800: Numbers n such that string 8,7 occurs in the base 10 representation of n but not of n+1.
; Submitted by Christian Krause
; 87,187,287,387,487,587,687,787,879,887,987,1087,1187,1287,1387,1487,1587,1687,1787,1879,1887,1987,2087,2187,2287,2387,2487,2587,2687,2787,2879,2887,2987,3087,3187,3287,3387,3487,3587
add $0,1
mul $0,10
mov $1,$0
add $0,9
div $0,11
mul $0,46
sub $1,3
div $1,11
add $1,3
add $0,$1
add $0,$1
add $0,$1
add $0,$1
sub $0,9
mul $0,20
sub $0,980
div $0,10
add $0,87
|
; A114431: Decimal expansion of the real solution of x^3 - x^2 - 2x - 4 = 0.
; Submitted by Christian Krause
; 2,4,6,7,5,0,3,8,5,7,0,5,6,5,1,7,5,7,6,3,8,1,8,8,6,7,5,5,3,5,8,7,8,6,0,7,0,3,8,2,2,5,4,4,7,5,0,6,2,3,7,2,9,8,8,4,6,4,0,1,9,7,7,4,0,5,5,0,7,5,1,9,3,5,9,1,7,7,3,3,9,7,1,5,8,1,5,9,5,1,6,3,4,9,2,3,8,6,3,5
bin $1,$0
mov $2,1
mov $3,$0
mul $3,4
lpb $3
add $1,$2
add $2,$1
add $1,$5
add $2,$1
sub $3,1
add $5,$2
lpe
mul $1,2
add $2,$5
mov $4,10
pow $4,$0
div $2,$4
div $1,$2
mov $0,$1
mod $0,10
|
; A338157: Numbers that follow from the alternating series a(n) = d(1) - d(2) + d(3) -d(4) + ... + (-1)^(n+1) d(n), where d(k) denotes the k-th term of the digit sequence of the Golden Ratio.
; Submitted by Jon Maiga
; 1,-5,-4,-12,-12,-15,-12,-21,-13,-21,-14,-18,-9,-17,-8,-12,-4,-8,0,-2,-2,-6,-1,-9,-3,-11,-8,-12,-9,-15,-10,-16,-13,-21,-20,-21,-14,-21,-19,-19,-16,-16,-7,-8,-1,-10,-2,-2,3,-4,2,0,8,2
mov $7,$0
add $7,1
mov $9,$0
lpb $7
mov $0,$9
mov $2,0
mov $6,3
sub $7,1
sub $0,$7
mov $1,1
mov $3,$0
mul $3,4
sub $3,$0
lpb $3
div $6,3
mul $6,2
add $1,$6
add $2,$1
mov $5,$1
mul $1,2
mul $2,2
sub $3,1
add $5,$2
add $6,$5
lpe
mov $4,-10
pow $4,$0
div $2,$4
cmp $10,0
add $2,$10
div $1,$2
mov $0,$1
mod $0,10
add $8,$0
lpe
mov $0,$8
|
; A017228: a(n) = (9*n + 5)^8.
; 390625,1475789056,78310985281,1099511627776,7984925229121,39062500000000,146830437604321,457163239653376,1235736291547681,2992179271065856,6634204312890625,13685690504052736,26584441929064321,49077072127303936,86730203469006241,147578905600000000,242935032749128801,388379855336079616,604967116961135041,920664383502155776,1372062286687890625,2006383000160502016,2883821021683985761,4080251070798954496,5690339646868044961,7831098528100000000,10645920227784266881,14309137159611744256,19031147999601100801,25064156467793879296,32708569488525390625,42320103423722192896,54317648809320741601,69191945760545587456,87515123947429289281,109951162777600000000,137267329159006474561,170346651950894039296,210201493946988852961,257988283970491580416,315023473396125390625,382800783150126981376,463009808974713123841,557556054479199010816,668582463235588483201,798492522912100000000,949975016173736007841,1126030494814647156736,1329999555322686599521,1565592995812193403136,1836923935996687890625,2148541983608805523456,2505469532410439724481,2913240278671707832576,3377940044732998170721,3906250000000000000000,4505492371457261922721,5183678737521468088576,5949561000791265348481,6812685136986118291456,7783447819102312890625,8873156017549873275136,10094089678769799935521,11459567586566681460736,12984016512127375695841,14683043760432100000000,16573513222499914075201,18673625044646222626816,21002999027665568907841,23582761870588633989376,26435638375398000390625,29586046730822882492416,33060197995068669948961,36886199899072774103296,41094165093613911202561,45716323965337600000000,50787142148496295121281,56343442860938221363456,62424534194614617885601,69072341492610745040896,76331544946441650390625,84249722549089334231296,92877498540993598756801,102268697487944508768256,112480504131560035634881,123573629154768100000000,135612481006447872516961,148665343931120835690496,162804562351317753689761,178106731751983340790016,194652896218016062890625,212528752777776150347776,231824862707130544151041,252636869950339141263616,275065726815822348736801,299217927106585600000000,325205746846812130518241,353147492767870953799936,383167758718722622528321,415397690167441003380736
mul $0,9
add $0,5
pow $0,8
|
cseg at 0h
jmp INIT
; Wait for first user input
org 0bh ; adresse v on timer interrupt
call LONG_PRESS_DETECED
reti ; return from interupt
org 1bh
call TIME_OVER
reti
INIT:
TIMER_START EQU 42d
BUTTON EQU P0.0
; Display init
MOV A,#30H ; Use 1 line and 5x7 matrix
ACALL CMND
MOV A,#0FH ; LCD ON, cursor ON, cursor blinking ON
ACALL CMND
MOV A,#01H ; Clear screen
ACALL CMND
MOV A,#06H ; shift cursor right
ACALL CMND
MOV A,#80H ; postion cursor
ACALL CMND
; End display init
MOV IE, #10001010b ;enables interupt
MOV R0, #1h
MOV R3, #190d; Error value
MOV R5, #0h
MOV TMOD, #00000000b
JMP BTN_LOOP
BTN_LOOP:; !pressed
clr tr0
CJNE R0, #1h, ANALYZE_PREV
;Run timer to detect break
CJNE R5, #0h, START_WAIT_TIMER
JNB BUTTON, START_TIMER
JMP BTN_LOOP
PRESSED:
MOV R0, #0
CLR TR1
JNB BUTTON, PRESSED
MOV R5, #1h
JB BUTTON, BTN_LOOP
START_TIMER:
mov tl1, #0FCh ; working #0C0h
mov th1, #0FCh ; working #0C0h
mov tl0, #0FCh ; working #0C0h
mov th0, #0FCh ; working #0C0h
setb tr0 ; startet timer
JMP PRESSED
START_WAIT_TIMER:
MOV R5, #0
mov tl1, #0FCh ; working #0C0h
mov th1, #0FCh ; working #0C0h
mov tl0, #0FCh ; working #0C0h
mov th0, #0FCh ; working #0C0h
setb tr1 ; startet timer
JMP BTN_LOOP
LONG_PRESS_DETECED:
mov r1,#1 ;save long press at R1
clr tr0 ;stop timer
RET
ANALYZE_PREV:
MOV A, R2
CJNE R1, #1h, SHORT_PRESS; if (not longpress)
CJNE R1, #0h, LONG_PRESS;
ANALYZE_PREV2:
MOV R2, A
MOV R0, #1
MOV R1, #0
MOV R5, #1h
MOV A, R6
SETB A.0
RL A
JB A.4, TIME_OVER_2
BACK_AGAIN:
MOV R6, A
JMP BTN_LOOP
LONG_PRESS:
RL A
SETB A.0
RL A
JMP ANALYZE_PREV2
SHORT_PRESS:
RL A
RL A
SETB A.0
JMP ANALYZE_PREV2
TIME_OVER_2:
CLR tr1
Call ENCODE_BITMASK
MOV R0, #1h
MOV R5, #0h
JMP BACK_AGAIN
TIME_OVER:
CLR tr1
Call ENCODE_BITMASK
MOV R0, #1h
RET
ENCODE_BITMASK:
MOV A, R2
CJNE A, #00000110b, ENCODE_BITMASK + 6; A
MOV R3, #0d
CJNE A, #10010101b, ENCODE_BITMASK + 11; B
MOV R3, #1d
CJNE A, #10011001b, ENCODE_BITMASK + 16; C
MOV R3, #2d
CJNE A, #00100101b, ENCODE_BITMASK + 21; D
MOV R3, #3d
CJNE A, #00000001b, ENCODE_BITMASK + 26; E
MOV R3, #4d
CJNE A, #01011001b, ENCODE_BITMASK + 31; F
MOV R3, #5d
CJNE A, #00101001b, ENCODE_BITMASK + 36; G
MOV R3, #6d
CJNE A, #01010101b, ENCODE_BITMASK + 41; H
MOV R3, #7d
CJNE A, #00000101b, ENCODE_BITMASK + 46; I
MOV R3, #8d
CJNE A, #01101010b, ENCODE_BITMASK + 51; J
MOV R3, #9d
CJNE A, #00100110b, ENCODE_BITMASK + 56; K
MOV R3, #10d
CJNE A, #01100101b, ENCODE_BITMASK + 61; L
MOV R3, #11d
CJNE A, #00001010b, ENCODE_BITMASK + 66; M
MOV R3, #12d
CJNE A, #00001001b, ENCODE_BITMASK + 71; N
MOV R3, #13d
CJNE A, #00101010b, ENCODE_BITMASK + 76; O
MOV R3, #14d
CJNE A, #01101001b, ENCODE_BITMASK + 81; P
MOV R3, #15d
CJNE A, #10100110b, ENCODE_BITMASK + 86; Q
MOV R3, #16d
CJNE A, #00011001b, ENCODE_BITMASK + 91; R
MOV R3, #17d
CJNE A, #00010101b, ENCODE_BITMASK + 96; S
MOV R3, #18d
CJNE A, #00000010b, ENCODE_BITMASK + 101; T
MOV R3, #19d
CJNE A, #00010110b, ENCODE_BITMASK + 106; U
MOV R3, #20d
CJNE A, #01010110b, ENCODE_BITMASK + 111; V
MOV R3, #21d
CJNE A, #00011010b, ENCODE_BITMASK + 116; W
MOV R3, #22d
CJNE A, #10010110b, ENCODE_BITMASK + 121; X
MOV R3, #23d
CJNE A, #10011010b, ENCODE_BITMASK + 126; Y
MOV R3, #24d
CJNE A, #10100101b, ENCODE_BITMASK + 131; Z
MOV R3, #25d
MOV A, R3
ADD A, #65d ; A is asci 65
MOV R4, A ; save value for led display
MOV R3, #190d; reset r3 to error: 190 + 65 = 255
CALL DISPLAY_LETTER
MOV R2, #0h
MOV R6, #0h
RET
CMND:
ACALL READY
CLR P0.1
CLR P0.2
MOV P1, A
SETB P0.3
CLR P0.3
RET
DISPLAY:
ACALL READY
MOV P1, A
SETB P0.1
CLR P0.2
SETB P0.3
CLR P0.3
RET
READY:
SETB P1.7
CLR P0.1
SETB P0.2
BACK:
SETB P0.3
CLR P0.3
JB P1.7, BACK
RET
;Set R/W Pin of the LCD HIGH(read from the LCD)
;Select the instruction register by setting RS pin LOW
;Enable the LCD by Setting the enable pin HIGH
; The most significant bit of the LCD data bus is the state of the busy flag(1=Busy,0=ready to accept instructions/data).The other bits hold the current value of the address counter.
DISPLAY_LETTER:
MOV A, R4
ACALL DISPLAY
RET
|
.align 4
sprite_pikachu:
.import "bin/sprite_pikachu.bin"
.align 4
sprite_pikachu_ow:
.import "bin/sprite_pikachu_ow.bin"
;eof |
# Demonstrates traversing a 2D array of words, storing a value at each
# cell of the array.
.data
matrix: .word 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
rows: .word 5
columns: .word 3
.text
.globl main
main:
la $t0, matrix
lw $t1, rows # number of rows
lw $t2, columns # number of columns
li $t3, 0 # i, row counter
row_loop:
li $t4, 0 # j, column counter
col_loop:
# Although this array traversal could be implemented by simply
# adding 4 to a starting address (e.g., matrix's address), the
# point here is to show the arithmetic of computing the address
# of an element in a 2D array when stored in row-major order.
# addr = base_addr + i * num_columns * elem_size_in_bytes + j * elem_size_in_bytes
# addr = base_addr + elem_size_in_bytes * (i * num_columns + j)
mul $t5, $t3, $t2 # i * num_columns
add $t5, $t5, $t4 # i * num_columns + j
sll $t5, $t5, 2 # 4*(i * num_columns + j) Mult by 4 b/c we have an array of 4-byte words
add $t5, $t5, $t0 # base_addr + 4*(i * num_columns + j)
lw $a0, 0($t5)
li $v0 1
syscall
li $a0, ' '
li $v0, 11
syscall
addi $t4, $t4, 1 # j++
blt $t4, $t2, col_loop
col_loop_done:
addi $t3, $t3, 1 # i++
blt $t3, $t1, row_loop
row_loop_done:
li $a0, '\n'
li $v0, 11
syscall
# Terminate the program
li $v0, 10
syscall
|
.text
.globl main
main:addu $zero,$zero,$zero
L_1:and $t2,$t2,$t2
L_2:and $t1,$t1,$t1
j L_2
j L_1
|
; A307989: a(n) = n - pi(2*n) + pi(n-1), where pi is the prime counting function.
; 0,0,1,2,3,4,4,6,6,6,7,8,9,11,11,11,12,14,14,16,16,16,17,18,19,20,20,21,22,23,23,25,26,26,27,27,27,29,30,30,31,32,33,35,35,36,37,39,39,40,40,40,41,42,42,43,43,44,45,47,48,50,51,51,52,52,53,55
mov $2,$0
add $2,2
mov $4,1
mov $5,$0
lpb $2
sub $2,1
mov $3,$5
seq $3,10051 ; Characteristic function of primes: 1 if n is prime, else 0.
sub $0,$3
add $5,1
lpe
add $0,$4
|
TITLE MISC2 - Miscellanious routines for MS-DOS
NAME MISC2
;
; Microsoft Confidential
; Copyright (C) Microsoft Corporation 1991
; All Rights Reserved.
;
;** MISC2.ASM - Miscellaneous useful routines
;
; StrCpy
; StrCmp
; StrLen
; DStrLen
; Idle
; TableDispatch
; FastInit ; DOS 4.0
; FastRet ; DOS 4.0
; NLS_OPEN ; DOS 4.0
; NLS_LSEEK ; DOS 4.0
; Fake_User_Stack ; DOS 4.0
; GetDevList ; DOS 4.0
; NLS_IOCTL ; DOS 4.0
; NLS_GETEXT ; DOS 4.0
; MSG_RETRIEVAL ; DOS 4.0
; Fake_Version ; DOS 4.0
;
; Revision history:
;
; Created: ARR 30 March 1983
;
; A000 version 4.0 Jan. 1988
; A001 DCR 486 - Share installation for >32mb drives
; A006 DCR 503 - fake version number for IBMCACHE
; DOS 5.00 Moved fake version to caller's PSP
.xlist
.xcref
include version.inc
include dosseg.inc
include dossym.inc
include sysvar.inc
include sf.inc
include curdir.inc
include fastxxxx.inc
include bugtyp.inc
.cref
.list
i_need THISCDS,DWORD
I_Need RetryLoop,WORD
I_need fSharing,BYTE ; TRUE => server-issued call
I_need FastTable,BYTE ;AN000;
I_need FastFlg,BYTE ;AN000;
I_need User_SP_2F,WORD ;AN000;
I_need User_SP,WORD ;AN000;
I_need User_SS,WORD ;AN000;
I_need SysInitTable,BYTE ;AN000;
I_need EXTERR,WORD ;AN000;
I_need MSG_EXTERROR,DWORD ;AN000;
I_need fshare,byte ;AN001;
I_need Special_version,WORD ;AN006;
DOSCODE SEGMENT
allow_getdseg
ASSUME SS:DOSDATA,CS:DOSCODE
Break <STRCMP - compare two ASCIZ strings DS:SI to ES:DI>
;----------------------------------------------------------------------------
;
; Strcmp - compare ASCIZ DS:SI to ES:DI. Case INSENSITIVE. '/' = '\'
; Strings of different lengths don't match.
; Inputs: DS:SI - pointer to source string ES:DI - pointer to dest string
; Outputs: Z if strings same, NZ if different
; Registers modified: NONE
;----------------------------------------------------------------------------
Procedure StrCmp,NEAR
ASSUME CS:DOSCODE,SS:DOSDATA
SAVE <SI,DI,AX>
Cmplp:
LODSB
IFDEF DBCS ;AN000;
invoke testkanj ;AN000;; 2/13/KK
jz notkanj1 ;AN000;; 2/13/KK
dec si ;AN000;; Do source again 2/13/KK
cmpsb ;AN000;; First byte 2/13/KK
JNZ PopRet ;AN000;; Strings dif 2/13/KK
cmpsb ;AN000;; Second byte of kanji char 2/13/KK
JNZ PopRet ;AN000;; Strings dif 2/13/KK
mov al,byte ptr [SI-1] ;AN000;; Need last byte in AL 2/13/KK
jmp short Tend ;AN000;
notkanj1: ;AN000;; 2/13/KK
ENDIF ;AN000;
invoke UCase ; convert to upper case
Invoke PathChrCmp ; convert / to \
MOV AH,AL
MOV AL,ES:[DI]
INC DI
invoke UCase ; convert to upper case
Invoke PathChrCmp ; convert / to \
CMP AH,AL
JNZ PopRet ; Strings dif
Tend:
OR AL,AL
JNZ Cmplp ; More string
PopRet:
RESTORE <AX,DI,SI>
return
EndProc StrCmp
Break <STRCPY - copy ASCIZ string from DS:SI to ES:DI>
;----------------------------------------------------------------------------
;
; Strcpy - copy an ASCIZ string from DS:SI to ES:DI and make uppercase
; FStrcpy - copy an ASCIZ string from DS:SI to ES:DI. no modification of
; characters.
;
; Inputs: DS:SI - pointer to source string
; ES:DI - pointer to destination string
; Outputs: ES:DI point byte after nul byte at end of dest string
; DS:SI point byte after nul byte at end of source string
; Registers modified: SI,DI
;----------------------------------------------------------------------------
Procedure StrCpy,NEAR
ASSUME CS:DOSCODE,SS:DOSDATA
SAVE <AX>
CPYLoop:
LODSB
IFDEF DBCS ;AN000;
invoke testkanj ;AN000;; 2/13/KK
jz notkanj2 ;AN000;; 2/13/KK
STOSB ;AN000;; 2/13/KK
LODSB ;AN000;; 2/13/KK
STOSB ;AN000;; 2/13/KK
jmp short CPYLoop ;AN000;; 3/31/KK
notkanj2: ;AN000;; 2/13/KK
ENDIF ;AN000;
invoke UCase ; convert to upper case
Invoke PathChrCmp ; convert / to \
STOSB
Tend2:
OR AL,AL
JNZ CPYLoop
RESTORE <AX>
return
EndProc StrCpy
;----------------------------------------------------------------------------
; Procedure Name : FStrCpy
;----------------------------------------------------------------------------
Procedure FStrCpy,NEAR
ASSUME CS:DOSCODE,SS:DOSDATA
SAVE <AX>
FCPYLoop:
LODSB
STOSB
OR AL,AL
JNZ FCPYLoop
RESTORE <AX>
return
EndProc FStrCpy
Break <StrLen - compute length of string ES:DI>
;** StrLen - Compute Length of String
;
; StrLen computes the length of a string, including the trailing 00
;
; ENTRY (es:di) = address of string
; EXIT (cx) = size of string
; USES cx, flags
Procedure StrLen,NEAR
ASSUME CS:DOSCODE,SS:DOSDATA
SAVE <di, ax>
MOV CX,-1
XOR AL,AL
REPNE SCASB
NOT CX
RESTORE <ax, di>
return
EndProc StrLen
;** DStrLen - Compute Length of String
;
; ENTRY (ds:si) = address of string
; EXIT (cx) = size of string, including trailing NUL
; USES cx, flags
Procedure DStrLen,NEAR ; BUGBUG - this guy is a pig, who uses him?
CALL XCHGP
CALL StrLen
CALL XCHGP
return
EndProc DStrLen
Break <XCHGP - exchange source and destination pointers>
;** XCHGP - Exchange Pointers
;
; XCHGP exchanges (DS:SI) and (ES:DI)
;
; ENTRY none
; EXIT pairs exchanged
; USES SI, DI, DS, ES
Procedure XCHGP,NEAR
SAVE <DS,ES>
RESTORE <DS,ES>
XCHG SI,DI
return
EndProc XCHGP
Break <Idle - wait for a specified amount of time>
;----------------------------------------------------------------------------
;
; Idle - when retrying an operation due to a lock/sharing violation, we spin
; until RetryLoop is exhausted.
;
; Inputs: RetryLoop is the number of times we spin
; Outputs: Wait
; Registers modified: none
;----------------------------------------------------------------------------
Procedure Idle,NEAR
ASSUME CS:DOSCODE,SS:DOSDATA
;hkn; SS override
cmp fSharing,0
retnz
SAVE <CX>
;hkn; SS override
MOV CX,RetryLoop
JCXZ Idle3
Idle1: PUSH CX
XOR CX,CX
Idle2: LOOP Idle2
POP CX
LOOP Idle1
Idle3: RESTORE <CX>
return
EndProc Idle
Break <TableDispatch - dispatch to a table>
;----------------------------------------------------------------------------
;
; TableDispatch - given a table and an index, jmp to the approptiate
; routine. Preserve all input registers to the routine.
;
; Inputs: Push return address
; Push Table address
; Push index (byte)
; Outputs: appropriate routine gets jumped to.
; return indicates invalid index
; Registers modified: none.
;----------------------------------------------------------------------------
TableFrame STRUC
OldBP DW ?
OldRet DW ?
Index DB ?
Pad DB ?
Tab DW ?
NewRet DW ?
TableFrame ENDS
procedure TableDispatch,NEAR
ASSUME CS:DOSCODE,SS:NOTHING
PUSH BP
MOV BP,SP
PUSH BX ; save BX
MOV BX,[BP.Tab] ; get pointer to table
MOV BL,CS:[BX] ; maximum index
CMP [BP.Index],BL ; table error?
JAE TableError ; yes
MOV BL,[BP.Index] ; get desired table index
XOR BH,BH ; convert to word
SHL BX,1 ; convert to word pointer
INC BX ; point past first length byte
ADD BX,[BP.Tab] ; get real offset
MOV BX,CS:[BX] ; get contents of table entry
MOV [BP.Tab],BX ; put table entry into return address
POP BX ; restore BX
POP BP ; restore BP
ADD SP,4 ; clean off Index and our return addr
return ; do operation
TableError:
POP BX ; restore BX
POP BP ; restore BP
RET 6 ; clean off Index, Table and RetAddr
EndProc TableDispatch
Break <TestNet - determine if a CDS is for the network>
;----------------------------------------------------------------------------
;
; TestNet - examine CDS pointed to by ThisCDS and see if it indicates a
; network CDS. This will handle NULL cds also.
;
; Inputs: ThisCDS points to CDS or NULL
; Outputs: ES:DI = ThisCDS
; carry Set => network
; carry Clear => local
; Registers modified: none.
;----------------------------------------------------------------------------
Procedure TestNet,NEAR
ASSUME CS:DOSCODE,SS:NOTHING
getdseg <es> ; es -> dosdata
LES DI,ThisCDS
assume es:NOTHING
CMP DI,-1
JZ CMCRet ; UNC? carry is clear
TESTB ES:[DI].curdir_flags,curdir_isnet
JNZ CMCret ; jump has carry clear
return ; carry is clear
CMCRet: CMC
return
EndProc TestNet
Break <IsSFTNet - see if an sft is for the network>
;----------------------------------------------------------------------------
;
; IsSFTNet - examine SF pointed to by ES:DI and see if it indicates a
; network file.
;
; Inputs: ES:DI point to SFT
; Outputs: Zero set if not network sft
; zero reset otherwise
; Carry CLEAR!!!
; Registers modified: none.
;----------------------------------------------------------------------------
Procedure IsSFTNet,NEAR
ASSUME CS:DOSCODE,SS:NOTHING
TESTB ES:[DI].sf_flags,sf_isnet
return
EndProc IsSFTNet
Break <FastInit - Initialize FastTable entries >
;----------------------------------------------------------------------------
; DOS 4.00 2/9/87
; FastInit - initialize the FASTXXX routine entry
; in the FastTable
;
; Inputs: BX = FASTXXX ID ( 1=fastopen )
; DS:SI = address of FASTXXX routine entry
; SI = -1 for query only
; Outputs: Carry flag clear, if success
; Carry flag set, if failure
;
;
;----------------------------------------------------------------------------
Procedure FastInit,NEAR
ASSUME CS:DOSCODE,SS:NOTHING
;hkn; set up es to dosdataseg.
push es
getdseg <es> ; es -> dosdata
;hkn; FastTable is in DOSDATA
MOV DI,OFFSET DOSDATA:FastTable + 2 ;AN000;FO. points to fastxxx entry
DEC BX ;AN000;FO.;; decrement index
MOV DX,BX ;AN000;FO.;; save bx
SHL BX,1 ;AN000;FO.;; times 4 , each entry is DWORD
SHL BX,1 ;AN000;FO.
ADD DI,BX ;AN000;FO. index to the entry
MOV AX,WORD PTR ES:[DI+2] ;AN000;FO. get entry segment
fcheck: ;AN000;
MOV CX,CS ;AN000;FO.;; get DOS segment
CMP AX,CX ;AN000;FO.;; first time installed ?
JZ ok_install ;AN000;FO.;; yes
OR AX,AX ;AN000;FO.;
JZ ok_install ;AN000;FO.;
STC ;AN000;FO.;; already installed !
JMP SHORT FSret ;AN000;FO. set carry
ok_install: ;AN000;
CMP SI,-1 ;AN000;FO.; Query only ?
JZ FSret ;AN000;FO.; yes
MOV CX,DS ;AN000;FO.; get FASTXXX entry segment
MOV WORD PTR ES:[DI+2],CX ;AN000;FO.; initialize routine entry
MOV WORD PTR ES:[DI],SI ;AN000;FO.; initialize routine offset
;hkn; FastFlg moved to DOSDATA
MOV DI,OFFSET DOSDATA:FastFlg ;AN000;FO.; get addr of FASTXXX flags
ADD DI,DX ;AN000;FO.; index to a FASTXXX flag
OR byte ptr ES:[DI],Fast_yes ;AN000;FO.; indicate installed
FSret: ;AN000;
pop es
return ;AN000;FO.
EndProc FastInit ;AN000;FO.
Break <FastRet - initial routine in FastOpenTable >
;----------------------------------------------------------------------------
; DOS 3.3 6/10/86
; FastRet - indicate FASTXXXX not in memory
;
; Inputs: None
; Outputs: AX = -1 and carry flag set
;
; Registers modified: none.
;----------------------------------------------------------------------------
Procedure FastRet,FAR
STC
sbb ax,ax ; (ax) = -1, 'C' set
RET
EndProc FastRet
Break <NLS_OPEN - do $open for NLSFUNC >
;----------------------------------------------------------------------------
; DOS 3.3 6/10/86
; NLS_OPEN - call $OPEN for NLSFUNC
;
; Inputs: Same input as $OPEN except CL = mode
; Outputs: same output as $OPEN
;
;----------------------------------------------------------------------------
;hkn; NOTE! SS MUST HAVE BEEN SET UP TO DOSDATA BY THE TIME THESE
;hkn; NLS FUNCTIONS ARE CALLED!!! THERE FORE WE WILL USE SS OVERRIDES
;hkn; IN ORDER TO ACCESS DOS DATA VARIABLES!
Procedure NLS_OPEN,NEAR
ASSUME CS:DOSCODE,SS:NOTHING
; MOV BL,[CPSWFLAG] ; disable code page matching logic
; MOV [CPSWFLAG],0
; PUSH BX ; save current state
MOV AL,CL ; set up correct interface for $OPEN
invoke $OPEN
; POP BX ; restore current state
; MOV [CPSWFLAG],BL
RET
EndProc NLS_OPEN
Break <NLS_LSEEK - do $LSEEK for NLSFUNC >
;----------------------------------------------------------------------------
; DOS 3.3 6/10/86
; NLS_LSEEK - call $LSEEK for NLSFUNC
;
; Inputs: BP = open mode
; Outputs: same output as $LSEEK
;
;----------------------------------------------------------------------------
Procedure NLS_LSEEK,NEAR
ASSUME CS:DOSCODE,SS:NOTHING
PUSH ss:[user_SP] ; save user stack
PUSH ss:[user_SS]
CALL Fake_User_Stack
MOV AX,BP ; set up correct interface for $LSEEK
invoke $LSEEK
POP ss:[user_SS] ; restore user stack
POP ss:[user_SP]
RET
EndProc NLS_LSEEK
Break <Fake_User_Stack - save user stack >
;----------------------------------------------------------------------------
; DOS 3.3 6/10/86
; Fake_User_Stack - save user stack pointer
;
;----------------------------------------------------------------------------
Procedure Fake_User_Stack,NEAR
ASSUME CS:DOSCODE,SS:NOTHING
MOV AX,ss:[User_SP_2F] ; replace with INT 2F stack
MOV ss:[user_SP],AX
;hkn; MOV AX,CS
mov ax, ss
MOV ss:[user_SS],AX ; DOSGROUP
RET
EndProc Fake_User_Stack
;
Break <GetDevList - get device header list pointer>
;----------------------------------------------------------------------------
; DOS 3.3 7/25/86
; GetDevList - get device header list pointer
;
; Output: AX:BX points to the device header list
;----------------------------------------------------------------------------
Procedure GetDevList,NEAR
ASSUME CS:DOSCODE,SS:DOSDATA
MOV SI,OFFSET DOSDATA:SysInitTable
;hkn; set up ds to point to DOSDATA
getdseg <ds> ; ds -> dosdata
LDS SI,[SI.SYSI_InitVars]
MOV AX,WORD PTR DS:[SI.SYSI_DEV]
MOV BX,WORD PTR DS:[SI.SYSI_DEV+2]
RET
EndProc GetDevList
Break <NLS_IOCTL - do $IOCTL for NLSFUNC >
;----------------------------------------------------------------------------
; DOS 3.3 7/25/86
; NLS_IOCTL - call $IOCTL for NLSFUNC
;
; Inputs: BP = function code 0CH
; Outputs: same output as generic $IOCTL
;
;----------------------------------------------------------------------------
Procedure NLS_IOCTL,NEAR
ASSUME CS:DOSCODE,SS:NOTHING
PUSH ss:[user_SP] ; save user stack
PUSH ss:[user_SS]
CALL Fake_User_Stack
MOV AX,BP ; set up correct interface for $LSEEK
invoke $IOCTL
POP ss:[user_SS] ; restore user stack
POP ss:[user_SP]
RET
EndProc NLS_IOCTL
Break <NLS_GETEXT- get extended error for NLSFUNC>
;----------------------------------------------------------------------------
; DOS 3.3 7/25/86
; NLS_GETEXT -
;
; Inputs: none
; Outputs: AX = extended error
;
;----------------------------------------------------------------------------
Procedure NLS_GETEXT,NEAR
ASSUME CS:DOSCODE,SS:NOTHING
MOV AX,SS:[EXTERR] ; return extended error
RET
EndProc NLS_GETEXT
Break <MSG_RETRIEVAL- get beginning addr of system and parser messages>
;----------------------------------------------------------------------------
; DOS 4.00
;
; Inputs: DL=0 get extended error message addr
; =1 set extended error message addr
; =2 get parser error message addr
; =3 set parser error message addr
; =4 get critical error message addr
; =5 set critical error message addr
; =6 get file system error message addr
; =7 set file system error message addr
; =8 get address for code reduction
; =9 set address for code reduction
; Function: get/set message address
; Outputs: ES:DI points to addr when get
;----------------------------------------------------------------------------
Procedure MSG_RETRIEVAL,NEAR
ASSUME CS:DOSCODE,SS:NOTHING
;; NOTE: This function lives in command.com resident code now.
;; If the int 2F ever gets this far, we'll return registers
;; unchanged, which produces the same result as before, if
;; command.com wasn't present (and therefore no messages available).
;;
;; I didn't point the entry in the 2F table to No_Op because
;; No_Op zeroes AL.
;;
;;;hkn; set up ds to point to DOSDATA
;; push ds
;; getdseg <ds> ; ds -> dosdata
;;
;; PUSH AX ;AN000;;MS. save regs
;; PUSH SI ;AN000;;MS. save regs
;; MOV AX,DX ;AN000;;MS.
;; MOV SI,OFFSET DOSDATA:MSG_EXTERROR ;AN000;;MS.
;; test AL,1 ;AN000;;MS. get ?
;; JZ toget ;AN000;;MS. yes
;; DEC AL ;AN000;;MS.
;;toget: ;AN000;
;; SHL AL,1 ;AN000;;MS. times 2
;; XOR AH,AH ;AN000;;MS.
;; ADD SI,AX ;AN000;;MS. position to the entry
;; test DL,1 ;AN000;;MS. get ?
;; JZ getget ;AN000;;MS. yes
;; MOV WORD PTR DS:[SI],DI ;AN000;;MS. set MSG
;; MOV WORD PTR DS:[SI+2],ES ;AN000;;MS. address to ES:DI
;; JMP SHORT MSGret ;AN000;;MS. exit
;;getget: ;AN000;
;; LES DI,DWORD PTR DS:[SI] ;AN000;;MS. get msg addr
;;MSGret: ;AN000;
;; POP SI ;AN000;;MS.
;; POP AX ;AN000;;MS.
;;
;; pop ds
return ;AN000;;MS. exit
EndProc MSG_RETRIEVAL ;AN000;
;***Break <Fake_version - set/reset version flag>
;***;----------------------------------------------------------------------------
;***;
;***; Inputs: DL=0 current version number
;***; <>0 special version number
;***; Function: set special version number
;***; Outputs: version number is changed
;***;
;***;----------------------------------------------------------------------------
;***
;***Procedure Fake_version,NEAR
;*** ASSUME CS:DOSCODE,SS:NOTHING
;***
;***;hkn; set up ds to point to DOSDATA
;*** push ds
;*** getdseg <ds> ; ds -> dosdata
;*** MOV [Special_version],DX ;AN006;MS.
;*** pop ds
;*** return ;AN006;;MS. exit
;***
;***EndProc Fake_version ;AN006;;MS.
DOSCODE ENDS
END
|
.global s_prepare_buffers
s_prepare_buffers:
ret
.global s_faulty_load
s_faulty_load:
push %r10
push %r11
push %r14
push %r9
push %rax
push %rbx
push %rcx
push %rdi
push %rdx
push %rsi
// Store
lea addresses_UC+0x184ac, %r9
nop
nop
nop
nop
nop
dec %rdx
movb $0x51, (%r9)
nop
nop
nop
inc %rdx
// Load
lea addresses_normal+0x35c0, %rbx
nop
nop
nop
nop
sub $14497, %r10
movups (%rbx), %xmm7
vpextrq $0, %xmm7, %r14
nop
nop
nop
nop
nop
and %r9, %r9
// Load
mov $0x3e5d620000000ce4, %r10
nop
nop
and %r9, %r9
movb (%r10), %dl
nop
nop
nop
nop
xor %rbx, %rbx
// Load
lea addresses_A+0x6ac, %rbx
nop
nop
nop
nop
nop
and %rdx, %rdx
mov (%rbx), %r11w
nop
nop
nop
nop
add %r11, %r11
// Store
lea addresses_WT+0x9c42, %rax
nop
nop
cmp $12821, %r14
movb $0x51, (%rax)
xor %r14, %r14
// Store
mov $0xb3c, %rax
nop
nop
nop
nop
cmp %rbx, %rbx
movl $0x51525354, (%rax)
nop
nop
nop
nop
nop
sub %r11, %r11
// Store
lea addresses_UC+0x7c63, %r9
nop
nop
nop
nop
nop
add %r11, %r11
mov $0x5152535455565758, %rbx
movq %rbx, %xmm7
movaps %xmm7, (%r9)
nop
nop
and %r9, %r9
// Store
lea addresses_UC+0x184ac, %rdx
nop
nop
and $51004, %rbx
mov $0x5152535455565758, %r11
movq %r11, %xmm0
vmovaps %ymm0, (%rdx)
nop
nop
nop
inc %r10
// Load
lea addresses_US+0xfca8, %r9
xor $17184, %r14
mov (%r9), %r11w
nop
nop
nop
xor $47959, %rdx
// REPMOV
lea addresses_normal+0x1e2c, %rsi
lea addresses_D+0x10a30, %rdi
nop
nop
nop
nop
sub $11897, %rdx
mov $35, %rcx
rep movsb
nop
cmp $55606, %r11
// REPMOV
lea addresses_UC+0x792c, %rsi
mov $0x4ac, %rdi
nop
nop
cmp $13752, %r14
mov $37, %rcx
rep movsw
sub %r11, %r11
// REPMOV
lea addresses_US+0x10894, %rsi
mov $0x71c46b00000008ac, %rdi
nop
nop
sub %r14, %r14
mov $86, %rcx
rep movsq
nop
nop
dec %rbx
// REPMOV
lea addresses_normal+0x1a2ac, %rsi
mov $0x67b03e00000003ac, %rdi
nop
nop
xor $43514, %rdx
mov $43, %rcx
rep movsb
nop
dec %rdx
// REPMOV
lea addresses_D+0x68ac, %rsi
lea addresses_WT+0x193a5, %rdi
clflush (%rdi)
nop
mfence
mov $113, %rcx
rep movsb
nop
dec %r9
// REPMOV
lea addresses_UC+0x5cac, %rsi
lea addresses_WC+0x147bc, %rdi
nop
nop
dec %r9
mov $45, %rcx
rep movsq
nop
nop
nop
nop
add %rax, %rax
// Faulty Load
lea addresses_UC+0x184ac, %r14
nop
and %rax, %rax
movups (%r14), %xmm6
vpextrq $0, %xmm6, %r10
lea oracles, %rbx
and $0xff, %r10
shlq $12, %r10
mov (%rbx,%r10,1), %r10
pop %rsi
pop %rdx
pop %rdi
pop %rcx
pop %rbx
pop %rax
pop %r9
pop %r14
pop %r11
pop %r10
ret
/*
<gen_faulty_load>
[REF]
{'src': {'type': 'addresses_UC', 'AVXalign': False, 'size': 8, 'NT': True, 'same': False, 'congruent': 0}, 'OP': 'LOAD'}
{'OP': 'STOR', 'dst': {'type': 'addresses_UC', 'AVXalign': False, 'size': 1, 'NT': False, 'same': True, 'congruent': 0}}
{'src': {'type': 'addresses_normal', 'AVXalign': False, 'size': 16, 'NT': False, 'same': False, 'congruent': 1}, 'OP': 'LOAD'}
{'src': {'type': 'addresses_NC', 'AVXalign': False, 'size': 1, 'NT': False, 'same': False, 'congruent': 1}, 'OP': 'LOAD'}
{'src': {'type': 'addresses_A', 'AVXalign': False, 'size': 2, 'NT': True, 'same': False, 'congruent': 8}, 'OP': 'LOAD'}
{'OP': 'STOR', 'dst': {'type': 'addresses_WT', 'AVXalign': False, 'size': 1, 'NT': False, 'same': False, 'congruent': 1}}
{'OP': 'STOR', 'dst': {'type': 'addresses_P', 'AVXalign': False, 'size': 4, 'NT': False, 'same': False, 'congruent': 3}}
{'OP': 'STOR', 'dst': {'type': 'addresses_UC', 'AVXalign': True, 'size': 16, 'NT': False, 'same': False, 'congruent': 0}}
{'OP': 'STOR', 'dst': {'type': 'addresses_UC', 'AVXalign': True, 'size': 32, 'NT': False, 'same': True, 'congruent': 0}}
{'src': {'type': 'addresses_US', 'AVXalign': True, 'size': 2, 'NT': False, 'same': False, 'congruent': 1}, 'OP': 'LOAD'}
{'src': {'type': 'addresses_normal', 'congruent': 6, 'same': False}, 'OP': 'REPM', 'dst': {'type': 'addresses_D', 'congruent': 2, 'same': False}}
{'src': {'type': 'addresses_UC', 'congruent': 7, 'same': False}, 'OP': 'REPM', 'dst': {'type': 'addresses_P', 'congruent': 9, 'same': False}}
{'src': {'type': 'addresses_US', 'congruent': 2, 'same': False}, 'OP': 'REPM', 'dst': {'type': 'addresses_NC', 'congruent': 7, 'same': False}}
{'src': {'type': 'addresses_normal', 'congruent': 6, 'same': False}, 'OP': 'REPM', 'dst': {'type': 'addresses_NC', 'congruent': 6, 'same': False}}
{'src': {'type': 'addresses_D', 'congruent': 10, 'same': False}, 'OP': 'REPM', 'dst': {'type': 'addresses_WT', 'congruent': 0, 'same': False}}
{'src': {'type': 'addresses_UC', 'congruent': 11, 'same': False}, 'OP': 'REPM', 'dst': {'type': 'addresses_WC', 'congruent': 4, 'same': False}}
[Faulty Load]
{'src': {'type': 'addresses_UC', 'AVXalign': False, 'size': 16, 'NT': False, 'same': True, 'congruent': 0}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'fc': 1}
fc
*/
|
; A349125: Dirichlet inverse of A064989, where A064989 is multiplicative with a(2^e) = 1 and a(p^e) = prevprime(p)^e for odd primes p.
; Submitted by Christian Krause
; 1,-1,-2,0,-3,2,-5,0,0,3,-7,0,-11,5,6,0,-13,0,-17,0,10,7,-19,0,0,11,0,0,-23,-6,-29,0,14,13,15,0,-31,17,22,0,-37,-10,-41,0,0,19,-43,0,0,0,26,0,-47,0,21,0,34,23,-53,0,-59,29,0,0,33,-14,-61,0,38,-15,-67,0,-71,31,0,0,35,-22,-73,0,0,37,-79,0,39,41,46,0,-83,0,55,0,58,43,51,0,-89,0,0,0
mov $1,$0
seq $0,64989 ; Multiplicative with a(2^e) = 1 and a(p^e) = prevprime(p)^e for odd primes p.
seq $1,8683 ; Möbius (or Moebius) function mu(n). mu(1) = 1; mu(n) = (-1)^k if n is the product of k different primes; otherwise mu(n) = 0.
mul $0,$1
|
; A187342: Floor(((15+sqrt(5))/11)n); complement of A187341.
; 1,3,4,6,7,9,10,12,14,15,17,18,20,21,23,25,26,28,29,31,32,34,36,37,39,40,42,43,45,47,48,50,51,53,54,56,57,59,61,62,64,65,67,68,70,72,73,75,76,78,79,81,83,84,86,87,89,90,92,94,95,97,98,100,101,103,104,106,108,109,111,112,114,115,117,119,120,122,123,125
mov $3,1
lpb $3
add $0,1
mul $0,188
mov $2,$0
div $0,120
add $0,$3
div $3,$2
lpe
sub $0,1
|
; A157215: Decimal expansion of 18 - 5*sqrt(2).
; Submitted by Christian Krause
; 1,0,9,2,8,9,3,2,1,8,8,1,3,4,5,2,4,7,5,5,9,9,1,5,5,6,3,7,8,9,5,1,5,0,9,6,0,7,1,5,1,6,4,0,6,2,3,1,1,5,2,5,9,6,3,4,1,1,6,6,0,1,3,1,0,0,4,6,3,3,7,6,0,7,6,8,9,4,6,4,8,0,5,7,4,8,0,6,2,3,2,8,3,6,1,7,9,2,1,3
mov $2,1
mov $3,$0
mul $3,4
lpb $3
mov $5,$4
sub $4,1
add $5,$2
add $1,$5
add $2,$1
mul $1,2
add $2,2
sub $3,1
pow $4,$5
lpe
mov $1,1
add $1,$5
mov $4,10
pow $4,$0
div $2,$4
div $1,$2
mov $0,$1
mod $0,10
|
/*
* Copyright 2014 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <atomic>
#include <glog/logging.h>
#include <random>
#include <memory>
#include <folly/Benchmark.h>
#include <folly/experimental/Bits.h>
std::random_device rd;
const size_t kBufferSize = 1 << 10;
std::vector<uint8_t> buffer(kBufferSize + 16);
template <class T>
void benchmarkSet(size_t n, T) {
size_t size = sizeof(T) * 6.9; // use 6.9 bits/byte
const size_t k = 16;
T values[k];
BENCHMARK_SUSPEND {
std::mt19937 gen(rd());
T max, min;
if (std::is_signed<T>::value) {
max = (T(1) << (size - 1)) - 1;
min = -(T(1) << (size - 1));
} else {
max = (T(1) << size) - 1;
min = 0;
}
CHECK_LE(folly::findLastSet(max), size);
CHECK_LE(folly::findLastSet(-min), size);
std::uniform_int_distribution<T> dis(min, max);
for (int i = 0; i < k; ++i) {
values[i] = dis(gen);
}
}
for (size_t i = 0; i < n; ++i) {
size_t bit = (i * 2973) % (kBufferSize * 8);
size_t drop = i % size;
folly::Bits<T>::set(reinterpret_cast<T *>(buffer.data()),
bit, size - drop, values[i % k] >> drop);
}
folly::doNotOptimizeAway(
folly::Bits<T>::test(reinterpret_cast<T *>(buffer.data()), 512));
}
BENCHMARK_NAMED_PARAM(benchmarkSet, u16, uint16_t());
BENCHMARK_RELATIVE_NAMED_PARAM(benchmarkSet, i16, int16_t());
BENCHMARK_NAMED_PARAM(benchmarkSet, u32, uint32_t());
BENCHMARK_RELATIVE_NAMED_PARAM(benchmarkSet, i32, int32_t());
BENCHMARK_NAMED_PARAM(benchmarkSet, u64, uint64_t());
BENCHMARK_RELATIVE_NAMED_PARAM(benchmarkSet, i64, int64_t());
BENCHMARK_DRAW_LINE();
std::atomic<int64_t> sum(0);
template <class T>
void benchmarkGet(size_t n, T x) {
size_t size = sizeof(T) * 6.9; // use 6.9 bits/byte
for (size_t i = 0; i < n; ++i) {
size_t bit = (i * 2973) % (kBufferSize * 8);
size_t drop = i % size;
x += folly::Bits<T>::get(
reinterpret_cast<T *>(buffer.data()), bit, size - drop);
}
folly::doNotOptimizeAway(x);
}
BENCHMARK_NAMED_PARAM(benchmarkGet, u16, uint16_t(0));
BENCHMARK_RELATIVE_NAMED_PARAM(benchmarkGet, i16, int16_t(0));
BENCHMARK_NAMED_PARAM(benchmarkGet, u32, uint32_t(0));
BENCHMARK_RELATIVE_NAMED_PARAM(benchmarkGet, i32, int32_t(0));
BENCHMARK_NAMED_PARAM(benchmarkGet, u64, uint64_t(0));
BENCHMARK_RELATIVE_NAMED_PARAM(benchmarkGet, i64, int64_t(0));
#if 0
============================================================================
folly/experimental/test/BitsBenchmark.cpp relative time/iter iters/s
============================================================================
benchmarkSet(u16) 8.58ns 116.59M
benchmarkSet(i16) 88.42% 9.70ns 103.08M
benchmarkSet(u32) 8.37ns 119.45M
benchmarkSet(i32) 88.23% 9.49ns 105.39M
benchmarkSet(u64) 9.23ns 108.34M
benchmarkSet(i64) 82.77% 11.15ns 89.68M
----------------------------------------------------------------------------
benchmarkGet(u16) 6.32ns 158.13M
benchmarkGet(i16) 80.40% 7.87ns 127.14M
benchmarkGet(u32) 6.34ns 157.65M
benchmarkGet(i32) 84.61% 7.50ns 133.39M
benchmarkGet(u64) 7.32ns 136.58M
benchmarkGet(i64) 85.78% 8.53ns 117.16M
============================================================================
#endif
int main(int argc, char *argv[]) {
gflags::ParseCommandLineFlags(&argc, &argv, true);
folly::runBenchmarks();
return sum.load();
}
|
;
; Sprite Rendering Routine
; original code by Patrick Davidson (TI 85)
; modified by Stefano Bodrato - Jan 2001
;
; Sept 2003 - Stefano: Fixed bug for sprites wider than 8.
;
; Much More Generic version
; Uses plotpixel, respixel and xorpixel
;
; ** putsprite3 is a thin version with a Self Modifying Code trick **
;
;
; $Id: putsprite3.asm $
;
IF !__CPU_INTEL__ & !__CPU_GBZ80__
SECTION smc_clib
PUBLIC putsprite
PUBLIC _putsprite
EXTERN swapgfxbk
EXTERN __graphics_end
EXTERN plotpixel
EXTERN respixel
EXTERN xorpixel
; __gfx_coords: h,l (vert-horz)
; sprite: (ix)
.putsprite
._putsprite
call swapgfxbk
ld hl,2
add hl,sp
ld e,(hl)
inc hl
ld d,(hl) ;sprite address
push ix
push de
pop ix
inc hl
ld e,(hl)
inc hl
inc hl
ld d,(hl) ; x and y __gfx_coords
inc hl
inc hl
ld a,(hl) ; and/or/xor mode
cp 166 ; and(hl) opcode
jr nz,nodoand
ld hl,respixel
ld (called+1),hl
jr doxor
.nodoand
cp 182 ; or(hl) opcode
jr nz,nodoor
ld hl,plotpixel
ld (called+1),hl
jr doxor
; 182 - or
; 174 - xor
.nodoor
ld hl,xorpixel
ld (called+1),hl
.doxor
ld h,d
ld l,e
ld a,(ix+0) ; Width
ld b,(ix+1) ; Height
.oloopx push bc ;Save # of rows
push af
;ld b,a ;Load width
ld b,0 ; Better, start from zero !!
ld c,(ix+2) ;Load one line of image
.iloopx sla c ;Test leftmost pixel
jr nc,noplotx ;See if a plot is needed
push hl
;push bc ; this should be done by the called routine
push de
ld a,h
add a,b
ld h,a
.called
call xorpixel
pop de
;pop bc
pop hl
.noplotx
inc b ; witdh counter
pop af
push af
cp b ; end of row ?
jr nz,noblkx
inc ix
ld c,(ix+2) ;Load next byte of image
jr noblockx
.noblkx
ld a,b ; next byte in row ?
;dec a
and a
jr z,iloopx
and 7
jr nz,iloopx
.blockx
inc ix
ld c,(ix+2) ;Load next byte of image
jr iloopx
.noblockx
inc l
pop af
pop bc ;Restore data
djnz oloopx
jp __graphics_end
ENDIF
|
;
; Copyright (c) 2016-2017 Heim László
;
; Snake written in assembly
; This application is also part of aengine library, being a demo application
;
; Main file of source code
;
%include 'third-party/io.inc' ; Message output
%include 'third-party/gfx.inc' ; Event handling
%include 'third-party/util.inc' ; Sleep
%include 'include/graphics/render.inc' ; For rendering functions
%include 'include/graphics/fonts.inc' ; For text rendering
%include 'include/graphics/sprite.inc' ; For image handling
%include 'include/demo/snake_map.inc' ; Game utilities
%include 'include/demo/score.inc' ; Score handling
%define sp_easy 4
%define sp_medium 3
%define sp_hard 2
global main
section .text
change_diff:
; Change difficulty of game
push eax
cmp dword [speed], sp_hard
je .change_easy
cmp dword [speed], sp_easy
je .change_medium
; Change to hard
mov dword [speed], sp_hard
mov eax, score_hard
jmp .loadscore
.change_easy:
mov dword [speed], sp_easy
mov eax, score_easy
jmp .loadscore
.change_medium:
mov dword [speed], sp_medium
mov eax, score_med
.loadscore:
call sr_saveToFile
call sr_loadFromFile
pop eax
ret
get_level_modifier:
; Return in ebx the level (0 - 2) based on speed
push eax
mov eax, [speed]
cmp eax, sp_easy
je .easy
cmp eax, sp_medium
je .medium
mov ebx, 2 ; Hard
jmp .exit
.medium:
mov ebx, 1
jmp .exit
.easy:
mov ebx, 0
.exit:
pop eax
ret
menuproc:
; Menu state process
push eax
push ebx
push ecx
push edi
push esi
mov eax, msg_enterMenuState
call io_writestr
call io_writeln
xor ecx, ecx
; Load up menu images
; Background
mov eax, menu_backg
call spr_load_gimp_ppm
test eax, eax
jz .alloc_failure
mov [menu_sprites+ecx*4], eax
inc ecx
; Start item
mov eax, menu_start
call spr_load_gimp_ppm
test eax, eax
jz .alloc_failure
mov [menu_sprites+ecx*4], eax
inc ecx
; Easy difficulty item
mov eax, menu_easy
call spr_load_gimp_ppm
test eax, eax
jz .alloc_failure
mov [menu_sprites+ecx*4], eax
inc ecx
; Medium difficulty item
mov eax, menu_medium
call spr_load_gimp_ppm
test eax, eax
jz .alloc_failure
mov [menu_sprites+ecx*4], eax
inc ecx
; Hard difficulty item
mov eax, menu_hard
call spr_load_gimp_ppm
test eax, eax
jz .alloc_failure
mov [menu_sprites+ecx*4], eax
inc ecx
; Exit item
mov eax, menu_exit
call spr_load_gimp_ppm
test eax, eax
jz .alloc_failure
mov [menu_sprites+ecx*4], eax
inc ecx
push ecx
xor ecx, ecx
; Start menu loop
.rendermenuloop:
; Render menu
; Check mouse state:
call gfx_getmouse
cmp eax, 0x0020
jl .mouse_read_exit
cmp eax, 0x014e
jg .mouse_read_exit
; It's maybe on a button
cmp ebx, 0x0100
jl .mouse_read_exit
cmp ebx, 0x0152
jle .select_0
cmp ebx, 0x015a
jl .mouse_read_exit
cmp ebx, 0x01ac
jle .select_1
cmp ebx, 0x01b1
jl .mouse_read_exit
cmp ebx, 0x0203
jg .mouse_read_exit
; Selection 2
mov ecx, 2
or esi, 1
jmp .mouse_read_ok
; Selection 0
.select_0:
mov ecx, 0
or esi, 1
jmp .mouse_read_ok
; Selection 1
.select_1:
mov ecx, 1
or esi, 1
jmp .mouse_read_ok
.mouse_read_exit:
and esi, 0
.mouse_read_ok:
.readeventsloop:
; Read events
call gfx_getevent
test eax, eax
jz .readeventsexit
cmp eax, 23
je .quitapp
cmp eax, 27
je .quitapp
cmp eax, 1
je .mpress
cmp eax, 273
je .moveup
cmp eax, 274
je .movedown
cmp eax, 13
je .selected
jmp .readeventsloop
.moveup:
; Move up selection
dec ecx
cmp ecx, 0
jge .readeventsloop
mov ecx, 2
jmp .readeventsloop
.movedown:
; Move down selection
inc ecx
cmp ecx, 3
jl .readeventsloop
mov ecx, 0
jmp .readeventsloop
.mpress:
; Mouse pressed:
test esi, 1
jz .readeventsloop
; Else check selection:
.selected:
; Check selection
cmp ecx, 0
je .playgame
cmp ecx, 1
je .highscores
mov edx, -1
jmp .readeventsloop
.playgame:
mov edx, 1
jmp .readeventsloop
.highscores:
; mov edx, 2
call change_diff
jmp .readeventsloop
.readeventsexit:
test edx, edx
jnz .exitnormal ; edx was modified, so we want to exit
; Back to render loop
mov eax, 0x00ffffff
call render_clear
; Render background
mov eax, [menu_sprites]
mov ebx, 0x00000000
call render_copyspr
; Save selection
mov edi, ecx
mov eax, edi
; Set rectangle size
mov ecx, 0x01320056
; Render menu items
; Play game item
cmp edi, 0
jne .nosel0
mov eax, 0x00402d00
mov ebx, 0x001d00fd
call render_renderRect
.nosel0:
mov eax, [menu_sprites+4]
mov ebx, 0x00200100
call render_copyspr
; Change difficulty item
cmp edi, 1
jne .nosel1
mov eax, 0x00402d00
mov ebx, 0x001d0157
call render_renderRect
.nosel1:
call get_level_modifier
mov eax, [menu_sprites+ebx*4+8]
mov ebx, 0x0020015a
call render_copyspr
; Render exit button
cmp edi, 2
jne .nosel2
mov eax, 0x00402d00
mov ebx, 0x001d01b1
call render_renderRect
.nosel2:
mov eax, [menu_sprites+20]
mov ebx, 0x002001b4
call render_copyspr
; Restore ecx
mov ecx, edi
; Render highscore table
mov ebx, 0x030000f0
call sr_renderTable
; Render framebuffer content
call render_show
jmp .rendermenuloop
.quitapp:
mov edx, -1 ; Exit requested
.exitnormal:
pop ecx
; Exit normally
.dealloc_loop0:
mov eax, [menu_sprites+ecx*4-4]
call spr_delete
loop .dealloc_loop0
; Restore registers
pop esi
pop edi
pop ecx
pop ebx
pop eax
ret
.alloc_failure:
mov eax, msg_alloc_error
call io_writestr
call io_writeln
; Dealloc images
test ecx, ecx
jz .exiterror
.dealloc_loop1:
mov eax, [menu_sprites+ecx*4-4]
call spr_delete
loop .dealloc_loop1
.exiterror:
mov edx, -1 ; Exit game due memory error
; Restore registers
pop edi
pop ecx
pop ebx
pop eax
ret
gameproc:
; Game state
push eax
push ebx
push ecx
push edi ; irany
push esi ; stepping
mov edi, 1
mov dword [last_dir], 1
xor esi, esi
mov eax, msg_enterGameState
call io_writestr
call io_writeln
; init game field (snake map)
call get_level_modifier
mov eax, ebx
call sm_initMap
.render_test_loop:
.eventloop:
call gfx_getevent
test eax, eax
jz .eventloopexit
cmp eax, 23
je .change_edx0
cmp eax, 27
je .change_edx1
cmp eax, 'p'
je .pause_unpause
cmp eax, 275
je .change_dir_right
cmp eax, 274
je .change_dir_down
cmp eax, 276
je .change_dir_left
cmp eax, 273
je .change_dir_up
jmp .eventloop
.change_edx0:
mov edx, -1
jmp .eventloop
.change_edx1:
xor edx, edx
jmp .eventloop
.change_dir_right:
cmp dword [last_dir], 0
je .eventloop
mov edi, 1
jmp .eventloop
.change_dir_down:
cmp dword [last_dir], 2
je .eventloop
mov edi, 3
jmp .eventloop
.change_dir_left:
cmp dword [last_dir], 1
je .eventloop
mov edi, 0
jmp .eventloop
.change_dir_up:
cmp dword [last_dir], 3
je .eventloop
mov edi, 2
jmp .eventloop
.pause_unpause:
cmp edx, 5
je .unpause
; Pause game
mov edx, 5
jmp .eventloop
.unpause:
mov edx, 2
jmp .eventloop
.eventloopexit:
cmp edx, 0
jle .render_exit
cmp edx, 5
je .no_dir_change ; No move, just rendering at pause
; Stepping
inc esi
cmp esi, [speed]
jb .no_dir_change
xor esi, esi
mov eax, edi
mov [last_dir], edi
call sm_moveSnake
jc .death
jmp .no_dir_change
.death:
call sm_queryFoodNum
call sr_testScore
jc .save_score
; No highscore
xor edx, edx
jmp .render_exit
.save_score:
; We have to save the score, so we jump to save screen, which has
; code 3 in state selector
; We will do a query again in the highscore window
mov edx, 3
jmp .render_exit
.no_dir_change:
mov eax, 0x00ff2020
call render_clear
call sm_renderMap
call render_show
jmp .render_test_loop
.render_exit:
; Exiting rendering
pop esi
pop edi
pop ecx
pop ebx
pop eax
ret
saveproc:
; No save processing currently!
push eax
mov eax, msg_enterSScrState
call io_writestr
call io_writeln
; Load background
mov eax, save_backg
call spr_load_gimp_ppm
test eax, eax
jz .alloc_failure
push ebx
push ecx
push edi
push esi
mov esi, eax ; Save background pointer
; Initialize name buffer
xor ecx, ecx
.init_buf:
mov byte [name_buffer+ecx], ' '
inc ecx
cmp ecx, 10
jb .init_buf
mov byte [name_buffer+ecx], 0
; Start saving name, move cursor to 0
xor edi, edi
.render_loop:
.event_loop:
call gfx_getevent
test eax, eax
jz .no_event
cmp eax, 23
je .end_save_0
cmp eax, 27
je .end_save_1
cmp eax, 13
je .end_save_1
cmp eax, 8
je .try_delete
cmp eax, 'a'
jb .event_loop
cmp eax, 'z'
jbe .char_press
jmp .event_loop
.end_save_0:
mov edx, -1
jmp .save
.end_save_1:
xor edx, edx
.save:
; Save the score:
call sm_queryFoodNum
mov ebx, name_buffer
call sr_pushScore
jmp .event_loop
.try_delete:
; Try to delete a char (pressed backspace)
test edi, edi
jz .event_loop ; No delete
dec edi
mov byte [name_buffer+edi], ' '
jmp .event_loop
.char_press:
; Pressed a character modify string
cmp edi, 10
je .event_loop ; Can't add character
mov [name_buffer+edi], al
inc edi
jmp .event_loop
.no_event:
; Continue drawing
cmp edx, 0
jle .exitstate
; Clear screen:
mov eax, 0x00ffffff
call render_clear
; Render background:
mov eax, esi
xor ebx, ebx
call render_copyspr
; Render save string:
mov eax, name_buffer
mov ebx, 0x01960150
call font_renderText
; Render points string:
call sm_queryFoodNum
mov ebx, 0x02400150
mov ecx, 3
call font_renderNumber
call render_show
jmp .render_loop
.exitstate:
; Exit save state:
pop esi
pop edi
pop ecx
pop ebx
pop eax
ret
.alloc_failure:
; Background allocation failure
mov edx, -1
pop eax
ret
main:
; Initialize fonts
mov eax, msg_initFonts
call io_writestr
call io_writeln
; Set font path
mov eax, fonts_relative_path
call font_loadFonts
jc .font_error
; Success
mov eax, msg_initFsuccess
call io_writestr
call io_writeln
; Create window
mov eax, msg_createWin
call io_writestr
call io_writeln
; Set up window properties
mov eax, [width]
mov ebx, [height]
mov ecx, 0
mov edx, title
call render_createWindow
jc .win_error
; Success
mov eax, msg_createWsuccess
call io_writestr
call io_writeln
; Load score table
mov eax, score_med
call sr_loadFromFile
; Enter state selection loop
; States:
; 0 - Menu state, 1 - Game state
mov eax, msg_enterStateSelL
call io_writestr
call io_writeln
; Set up state
xor edx, edx
; Set speed (I have to change this later...)
mov esi, sp_medium ; Loaded medium score data, so we set medium
; speed
mov [speed], esi
.stateloop:
; State loop:
test edx, edx
jz .menustart
cmp edx, 1
je .gamestart
; cmp edx, 2
; je .highscore
cmp edx, 3
je .savescore
; Menu returned other number, so exit is requested
jmp .exitgame
.menustart:
; Start menu state
call menuproc
jmp .stateloop
.gamestart:
; Start a game
call gameproc
jmp .stateloop
; .highscore:
; ; Start highscore state
; call scoreproc
; jmp .stateloop
.savescore:
; Save new score in highscores table
call saveproc
jmp .stateloop
.exitgame:
; Try to save score if modified
call sr_saveToFile
; Exit application
mov eax, msg_exit
call io_writestr
call io_writeln
call render_destroyWindow
call font_free
; Game exit #0 - without error
ret
.win_error:
; Exit application due window creation error
mov eax, msg_createWfailure
call io_writestr
call io_writeln
call font_free
; Game exit #1 - window error
ret
.font_error:
mov eax, msg_initFfailure
call io_writestr
call io_writeln
; Game exit #2 - font load error
ret
section .bss
; Menu sprite cache
menu_sprites resd 6
last_dir resd 1
speed resd 1
; Name buffer:
name_buffer resb 11
section .data
; State messages
msg_initFonts db 'Initializing fonts...', 0
msg_initFsuccess db 'Fonts initialized successfully!', 0
msg_initFfailure db 'Could not initialize fonts!', 0
msg_initCards db 'Initializing cards...', 0
msg_initCsuccess db 'Cards initialized successfully!', 0
msg_initCfailure db 'Could not load cards!', 0
msg_createWin db 'Creating window...', 0
msg_createWsuccess db 'Window created successfully!', 0
msg_createWfailure db 'Could not create window!', 0
msg_enterStateSelL db 'Entering state selection loop...', 0
msg_enterMenuState db 'Entering menu state...', 0
msg_enterGameState db 'Entering game state...', 0
msg_enterHScrState db 'Entering highscore menu state...', 0
msg_enterSScrState db 'Entering save score screen...', 0
msg_alloc_error db 'Couldn not allocate memory, or resource missing!', 0
msg_exit db 'Exiting application...', 0
; Window data
width dd 1024
height dd 768
title db 'Snake clone by Heim Laszlo', 0
; Font data
fonts_relative_path db '..\resources\fonts\', 0
; Score file
scoredat db 'score.sav', 0
; Score files
score_easy db 'score0.sav', 0
score_med db 'score1.sav', 0
score_hard db 'score2.sav', 0
; Menu filenames
menu_backg db '..\resources\background1.ppm', 0
menu_start db '..\resources\start.ppm', 0
menu_easy db '..\resources\easy.ppm', 0
menu_medium db '..\resources\medium.ppm', 0
menu_hard db '..\resources\hard.ppm', 0
menu_exit db '..\resources\exit.ppm', 0
; Highscore screen filename
high_backg db '..\resources\background2.ppm', 0
; Save screen filename
save_backg db '..\resources\background3.ppm', 0
|
; A077932: Expansion of (1-x)^(-1)/(1+2*x+2*x^2-2*x^3).
; Submitted by Jamie Morken(s2)
; 1,-1,1,3,-9,15,-5,-37,115,-165,27,507,-1397,1835,139,-6741,16875,-19989,-7253,88235,-201941,212907,154539,-1138773,2394283,-2201941,-2662229,14516907,-28113237,21868203,41523883,-183010645,326709931,-204350805,-610739541,2283600555,-3754423637
mov $3,1
lpb $0
sub $0,1
mul $3,2
add $1,$3
sub $3,$1
add $1,$3
add $1,$2
sub $2,$1
add $3,$2
add $3,1
lpe
mov $0,$3
|
#include <angelscript/angelscript.h>
#include "script.h"
#include "entity/scene.h"
namespace Crimson {
ScriptComponent::ScriptComponent(const char* behaviourDecl) :
m_behaviourDecl(behaviourDecl) {}
void ScriptComponent::OnInit() {
/* Create an instance of the object with the class name */
m_behaviour = m_entity->m_scene->m_scriptManager->
CreateInstance(m_behaviourDecl.c_str(), m_entity);
std::vector<BehaviourField> invalidFields;
/* Set up serialisable fields */
for (auto& f : m_serialisableFloats) {
if (!m_entity->m_scene->m_scriptManager->SetFloatProperty(m_behaviour, f.first, f.second)) {
invalidFields.push_back(f.first);
}
}
for (auto& f : m_serialisableInts) {
if (!m_entity->m_scene->m_scriptManager->SetIntProperty(m_behaviour, f.first, f.second)) {
invalidFields.push_back(f.first);
}
}
for (auto& f : m_serialisableStrings) {
if (!m_entity->m_scene->m_scriptManager->SetStringProperty(m_behaviour, f.first, f.second)) {
invalidFields.push_back(f.first);
}
}
/* Only reset if the script manager is compiled, otherwise the user
* might lose data if they make a mistake */
if (m_entity->m_scene->m_scriptManager->CompilationSuccess()) {
for (auto& f : invalidFields) {
try {
m_serialisableFloats.erase(f);
} catch (const std::exception& e) {}
try {
m_serialisableInts.erase(f);
} catch (const std::exception& e) {}
try {
m_serialisableStrings.erase(f);
} catch (const std::exception& e) {}
}
}
if (!m_dontCallInit) {
/* Call the script's OnInit function */
m_entity->m_scene->m_scriptManager->CallInit(m_behaviour);
}
}
void ScriptComponent::ClearSerialisableValues() {
m_serialisableFloats.clear();
m_serialisableInts.clear();
m_serialisableStrings.clear();
}
void ScriptComponent::OnUpdate(float delta) {
/* Call the script's OnUpdate function */
m_entity->m_scene->m_scriptManager->CallUpdate(m_behaviour, delta);
}
void ScriptComponent::OnDestroy() {
/* This is kind of ugly. It's to prevent a double free, if for some
* reason this function is called more than once (which can happen). */
if (m_behaviour.instance) {
m_behaviour.instance->Release();
m_behaviour.instance = NULL;
}
}
}
|
;
; Z88dk Generic Floating Point Math Library
;
; increment c ix de
;
; $Id: incr.asm,v 1.1 2002/01/21 20:35:22 dom Exp $:
XLIB incr
.INCR INC E ;increment c ix de
RET NZ
INC D
RET NZ
DEFB $DD
INC L
RET NZ
DEFB $DD
INC H
RET NZ
INC C
RET NZ ;z => carry
LD C,$80 ;set high order bit
INC (HL) ; and increment exponent
RET NZ
ret
; JP OFLOW
|
; void qsort(void *base, size_t nmemb, size_t size, int (*compar)(const void *, const void *))
SECTION code_clib
SECTION code_stdlib
PUBLIC _quicksort__callee
EXTERN asm_quicksort
_quicksort__callee:
pop af
pop ix
pop de
pop hl
pop bc
push af
jp asm_quicksort
|
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14}}
// <istream>
// template <class charT, class traits = char_traits<charT> >
// class basic_istream;
// basic_istream<charT,traits>& operator>>(basic_streambuf<charT,traits>* sb);
#include <istream>
#include <cassert>
#include "test_macros.h"
template <class CharT>
class testbuf
: public std::basic_streambuf<CharT>
{
typedef std::basic_streambuf<CharT> base;
std::basic_string<CharT> str_;
public:
testbuf()
{
}
testbuf(const std::basic_string<CharT>& str)
: str_(str)
{
base::setg(const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data() + str_.size()));
}
std::basic_string<CharT> str() const
{return std::basic_string<CharT>(base::pbase(), base::pptr());}
protected:
virtual typename base::int_type
overflow(typename base::int_type ch = base::traits_type::eof())
{
if (ch != base::traits_type::eof())
{
std::size_t n = str_.size();
str_.push_back(static_cast<CharT>(ch));
str_.resize(str_.capacity());
base::setp(const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data() + str_.size()));
base::pbump(static_cast<int>(n+1));
}
return ch;
}
};
int main(int, char**)
{
{
testbuf<char> sb("testing...");
std::istream is(&sb);
testbuf<char> sb2;
is >> &sb2;
assert(sb2.str() == "testing...");
assert(is.gcount() == 10);
}
#ifndef TEST_HAS_NO_EXCEPTIONS
{
testbuf<char> sb(" ");
std::basic_istream<char> is(&sb);
testbuf<char> sb2;
is.exceptions(std::istream::eofbit);
bool threw = false;
try {
is >> &sb2;
} catch (std::ios_base::failure&) {
threw = true;
}
assert(threw);
assert(!is.bad());
assert( is.eof());
assert(!is.fail());
}
#ifndef TEST_HAS_NO_WIDE_CHARACTERS
{
testbuf<wchar_t> sb(L" ");
std::basic_istream<wchar_t> is(&sb);
testbuf<wchar_t> sb2;
is.exceptions(std::istream::eofbit);
bool threw = false;
try {
is >> &sb2;
} catch (std::ios_base::failure&) {
threw = true;
}
assert(threw);
assert(!is.bad());
assert( is.eof());
assert(!is.fail());
}
#endif
{
testbuf<char> sb;
std::basic_istream<char> is(&sb);
testbuf<char> sb2;
is.exceptions(std::istream::failbit);
bool threw = false;
try {
is >> &sb2;
} catch (std::ios_base::failure&) {
threw = true;
}
assert(threw);
assert(!is.bad());
assert( is.eof());
assert( is.fail());
}
#ifndef TEST_HAS_NO_WIDE_CHARACTERS
{
testbuf<wchar_t> sb;
std::basic_istream<wchar_t> is(&sb);
testbuf<wchar_t> sb2;
is.exceptions(std::istream::failbit);
bool threw = false;
try {
is >> &sb2;
} catch (std::ios_base::failure&) {
threw = true;
}
assert(threw);
assert(!is.bad());
assert( is.eof());
assert( is.fail());
}
#endif
{
testbuf<char> sb;
std::basic_istream<char> is(&sb);
is.exceptions(std::istream::failbit);
bool threw = false;
try {
is >> static_cast<testbuf<char>*>(0);
} catch (std::ios_base::failure&) {
threw = true;
}
assert(threw);
assert(!is.bad());
assert(!is.eof());
assert( is.fail());
}
#ifndef TEST_HAS_NO_WIDE_CHARACTERS
{
testbuf<wchar_t> sb;
std::basic_istream<wchar_t> is(&sb);
is.exceptions(std::istream::failbit);
bool threw = false;
try {
is >> static_cast<testbuf<wchar_t>*>(0);
} catch (std::ios_base::failure&) {
threw = true;
}
assert(threw);
assert(!is.bad());
assert(!is.eof());
assert( is.fail());
}
#endif
#endif // TEST_HAS_NO_EXCEPTIONS
return 0;
}
|
#ifndef ADD_TWO_NUMBERS_AS_LINKED_LISTS_HPP
#define ADD_TWO_NUMBERS_AS_LINKED_LISTS_HPP
// https://leetcode.com/problems/add-two-numbers/description/
// You are given two non-empty linked lists representing two non-negative
// integers. The digits are stored in reverse order and each of their nodes
// contain a single digit. Add the two numbers and return it as a linked list.
// You may assume the two numbers do not contain any leading zero, except the
// number 0 itself.
// Input: (2 -> 4 -> 3) + (5 -> 6 -> 4)
// Output: 7 -> 0 -> 8
#include <algorithm>
#include "types/ds/singly_linked_list_nodes.hpp"
namespace Algo::DS::SLL {
template <typename T>
class AddNumbersSLL {
public:
static NodeSLL<T>* Add(NodeSLL<T>* l1, NodeSLL<T>* l2) {
NodeSLL<T>* start = nullptr;
NodeSLL<T>* node = nullptr;
int carry = 0;
while(true) {
if (l1 == nullptr && l2 == nullptr && carry == 0) {
break;
}
else {
NodeSLL<T>* nextNode = new NodeSLL<T>(0);
if (start == nullptr) {
start = node = nextNode;
}
else {
node->next = nextNode;
node = node->next;
}
}
int sum = (l1 == nullptr ? 0 : l1->value) +
(l2 == nullptr ? 0 : l2->value) +
carry;
node->value = sum % 10;
carry = sum / 10;
l1 != nullptr ? l1 = l1->next : l1;
l2 != nullptr ? l2 = l2->next : l2;
}
return start;
}
};
}
#endif // ADD_TWO_NUMBERS_AS_LINKED_LISTS_HPP
|
//---------------------------------------------------------------------------
// Greenplum Database
// Copyright (C) 2011 EMC Corp.
//
// @filename:
// CParseHandlerLogicalGroupBy.cpp
//
// @doc:
// Implementation of the SAX parse handler class for parsing logical
// GroupBy operators.
//---------------------------------------------------------------------------
#include "naucrates/dxl/parser/CParseHandlerLogicalGroupBy.h"
#include "naucrates/dxl/operators/CDXLLogicalGroupBy.h"
#include "naucrates/dxl/operators/CDXLOperatorFactory.h"
#include "naucrates/dxl/parser/CParseHandlerFactory.h"
#include "naucrates/dxl/parser/CParseHandlerGroupingColList.h"
#include "naucrates/dxl/parser/CParseHandlerProjList.h"
#include "naucrates/dxl/parser/CParseHandlerScalarOp.h"
using namespace gpdxl;
XERCES_CPP_NAMESPACE_USE
//---------------------------------------------------------------------------
// @function:
// CParseHandlerLogicalGroupBy::CParseHandlerLogicalGroupBy
//
// @doc:
// Constructor
//
//---------------------------------------------------------------------------
CParseHandlerLogicalGroupBy::CParseHandlerLogicalGroupBy(
CMemoryPool *mp, CParseHandlerManager *parse_handler_mgr,
CParseHandlerBase *parse_handler_root)
: CParseHandlerLogicalOp(mp, parse_handler_mgr, parse_handler_root)
{
}
//---------------------------------------------------------------------------
// @function:
// CParseHandlerLogicalGroupBy::StartElement
//
// @doc:
// Invoked by Xerces to process an opening tag
//
//---------------------------------------------------------------------------
void
CParseHandlerLogicalGroupBy::StartElement(const XMLCh *const, // element_uri,
const XMLCh *const element_local_name,
const XMLCh *const, // element_qname
const Attributes & //attrs
)
{
if (0 ==
XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenLogicalGrpBy),
element_local_name))
{
m_dxl_node = GPOS_NEW(m_mp)
CDXLNode(m_mp, GPOS_NEW(m_mp) CDXLLogicalGroupBy(m_mp));
// create child node parsers
// parse handler for logical operator
CParseHandlerBase *lg_op_parse_handler =
CParseHandlerFactory::GetParseHandler(
m_mp, CDXLTokens::XmlstrToken(EdxltokenLogical),
m_parse_handler_mgr, this);
m_parse_handler_mgr->ActivateParseHandler(lg_op_parse_handler);
// parse handler for the proj list
CParseHandlerBase *proj_list_parse_handler =
CParseHandlerFactory::GetParseHandler(
m_mp, CDXLTokens::XmlstrToken(EdxltokenScalarProjList),
m_parse_handler_mgr, this);
m_parse_handler_mgr->ActivateParseHandler(proj_list_parse_handler);
//parse handler for the grouping columns list
CParseHandlerBase *grouping_col_list_parse_handler =
CParseHandlerFactory::GetParseHandler(
m_mp, CDXLTokens::XmlstrToken(EdxltokenScalarGroupingColList),
m_parse_handler_mgr, this);
m_parse_handler_mgr->ActivateParseHandler(
grouping_col_list_parse_handler);
// store child parse handler in array
this->Append(grouping_col_list_parse_handler);
this->Append(proj_list_parse_handler);
this->Append(lg_op_parse_handler);
}
else
{
CWStringDynamic *str = CDXLUtils::CreateDynamicStringFromXMLChArray(
m_parse_handler_mgr->GetDXLMemoryManager(), element_local_name);
GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag,
str->GetBuffer());
}
}
//---------------------------------------------------------------------------
// @function:
// CParseHandlerLogicalGroupBy::EndElement
//
// @doc:
// Invoked by Xerces to process a closing tag
//
//---------------------------------------------------------------------------
void
CParseHandlerLogicalGroupBy::EndElement(const XMLCh *const, // element_uri,
const XMLCh *const element_local_name,
const XMLCh *const // element_qname
)
{
if (0 !=
XMLString::compareString(CDXLTokens::XmlstrToken(EdxltokenLogicalGrpBy),
element_local_name))
{
CWStringDynamic *str = CDXLUtils::CreateDynamicStringFromXMLChArray(
m_parse_handler_mgr->GetDXLMemoryManager(), element_local_name);
GPOS_RAISE(gpdxl::ExmaDXL, gpdxl::ExmiDXLUnexpectedTag,
str->GetBuffer());
}
GPOS_ASSERT(nullptr != m_dxl_node);
GPOS_ASSERT(3 == this->Length());
CParseHandlerGroupingColList *grouping_col_parse_handler =
dynamic_cast<CParseHandlerGroupingColList *>((*this)[0]);
CParseHandlerProjList *proj_list_parse_handler =
dynamic_cast<CParseHandlerProjList *>((*this)[1]);
CParseHandlerLogicalOp *lg_op_parse_handler =
dynamic_cast<CParseHandlerLogicalOp *>((*this)[2]);
GPOS_ASSERT(nullptr != proj_list_parse_handler->CreateDXLNode());
GPOS_ASSERT(nullptr != lg_op_parse_handler->CreateDXLNode());
AddChildFromParseHandler(proj_list_parse_handler);
AddChildFromParseHandler(lg_op_parse_handler);
CDXLLogicalGroupBy *lg_group_by_dxl =
static_cast<CDXLLogicalGroupBy *>(m_dxl_node->GetOperator());
// set grouping cols list
GPOS_ASSERT(nullptr != grouping_col_parse_handler->GetGroupingColidArray());
ULongPtrArray *grouping_col_array =
grouping_col_parse_handler->GetGroupingColidArray();
grouping_col_array->AddRef();
lg_group_by_dxl->SetGroupingColumns(grouping_col_array);
#ifdef GPOS_DEBUG
lg_group_by_dxl->AssertValid(m_dxl_node, false /* validate_children */);
#endif // GPOS_DEBUG
// deactivate handler
m_parse_handler_mgr->DeactivateHandler();
}
// EOF
|
_init: file format elf32-i386
Disassembly of section .text:
00000000 <main>:
char *argv[] = { "sh", 0 };
int
main(void)
{
0: 55 push %ebp
1: 89 e5 mov %esp,%ebp
3: 53 push %ebx
4: 83 e4 f0 and $0xfffffff0,%esp
7: 83 ec 10 sub $0x10,%esp
int pid, wpid;
if(open("console", O_RDWR) < 0){
a: c7 44 24 04 02 00 00 movl $0x2,0x4(%esp)
11: 00
12: c7 04 24 f6 07 00 00 movl $0x7f6,(%esp)
19: e8 54 03 00 00 call 372 <open>
1e: 85 c0 test %eax,%eax
20: 0f 88 b2 00 00 00 js d8 <main+0xd8>
mknod("console", 1, 1);
open("console", O_RDWR);
}
dup(0); // stdout
26: c7 04 24 00 00 00 00 movl $0x0,(%esp)
2d: e8 78 03 00 00 call 3aa <dup>
dup(0); // stderr
32: c7 04 24 00 00 00 00 movl $0x0,(%esp)
39: e8 6c 03 00 00 call 3aa <dup>
3e: 66 90 xchg %ax,%ax
for(;;){
printf(1, "init: starting sh\n");
40: c7 44 24 04 fe 07 00 movl $0x7fe,0x4(%esp)
47: 00
48: c7 04 24 01 00 00 00 movl $0x1,(%esp)
4f: e8 3c 04 00 00 call 490 <printf>
pid = fork();
54: e8 d1 02 00 00 call 32a <fork>
if(pid < 0){
59: 85 c0 test %eax,%eax
pid = fork();
5b: 89 c3 mov %eax,%ebx
if(pid < 0){
5d: 78 33 js 92 <main+0x92>
5f: 90 nop
printf(1, "init: fork failed\n");
exit();
}
if(pid == 0){
60: 74 49 je ab <main+0xab>
62: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
exec("sh", argv);
printf(1, "init: exec sh failed\n");
exit();
}
while((wpid=wait(0)) >= 0 && wpid != pid)
68: c7 04 24 00 00 00 00 movl $0x0,(%esp)
6f: e8 c6 02 00 00 call 33a <wait>
74: 85 c0 test %eax,%eax
76: 78 c8 js 40 <main+0x40>
78: 39 d8 cmp %ebx,%eax
7a: 74 c4 je 40 <main+0x40>
printf(1, "zombie!\n");
7c: c7 44 24 04 3d 08 00 movl $0x83d,0x4(%esp)
83: 00
84: c7 04 24 01 00 00 00 movl $0x1,(%esp)
8b: e8 00 04 00 00 call 490 <printf>
90: eb d6 jmp 68 <main+0x68>
printf(1, "init: fork failed\n");
92: c7 44 24 04 11 08 00 movl $0x811,0x4(%esp)
99: 00
9a: c7 04 24 01 00 00 00 movl $0x1,(%esp)
a1: e8 ea 03 00 00 call 490 <printf>
exit();
a6: e8 87 02 00 00 call 332 <exit>
exec("sh", argv);
ab: c7 44 24 04 c4 0a 00 movl $0xac4,0x4(%esp)
b2: 00
b3: c7 04 24 24 08 00 00 movl $0x824,(%esp)
ba: e8 ab 02 00 00 call 36a <exec>
printf(1, "init: exec sh failed\n");
bf: c7 44 24 04 27 08 00 movl $0x827,0x4(%esp)
c6: 00
c7: c7 04 24 01 00 00 00 movl $0x1,(%esp)
ce: e8 bd 03 00 00 call 490 <printf>
exit();
d3: e8 5a 02 00 00 call 332 <exit>
mknod("console", 1, 1);
d8: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp)
df: 00
e0: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp)
e7: 00
e8: c7 04 24 f6 07 00 00 movl $0x7f6,(%esp)
ef: e8 86 02 00 00 call 37a <mknod>
open("console", O_RDWR);
f4: c7 44 24 04 02 00 00 movl $0x2,0x4(%esp)
fb: 00
fc: c7 04 24 f6 07 00 00 movl $0x7f6,(%esp)
103: e8 6a 02 00 00 call 372 <open>
108: e9 19 ff ff ff jmp 26 <main+0x26>
10d: 66 90 xchg %ax,%ax
10f: 90 nop
00000110 <strcpy>:
#include "user.h"
#include "x86.h"
char*
strcpy(char *s, const char *t)
{
110: 55 push %ebp
111: 89 e5 mov %esp,%ebp
113: 8b 45 08 mov 0x8(%ebp),%eax
116: 8b 4d 0c mov 0xc(%ebp),%ecx
119: 53 push %ebx
char *os;
os = s;
while((*s++ = *t++) != 0)
11a: 89 c2 mov %eax,%edx
11c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
120: 83 c1 01 add $0x1,%ecx
123: 0f b6 59 ff movzbl -0x1(%ecx),%ebx
127: 83 c2 01 add $0x1,%edx
12a: 84 db test %bl,%bl
12c: 88 5a ff mov %bl,-0x1(%edx)
12f: 75 ef jne 120 <strcpy+0x10>
;
return os;
}
131: 5b pop %ebx
132: 5d pop %ebp
133: c3 ret
134: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
13a: 8d bf 00 00 00 00 lea 0x0(%edi),%edi
00000140 <strcmp>:
int
strcmp(const char *p, const char *q)
{
140: 55 push %ebp
141: 89 e5 mov %esp,%ebp
143: 8b 55 08 mov 0x8(%ebp),%edx
146: 53 push %ebx
147: 8b 4d 0c mov 0xc(%ebp),%ecx
while(*p && *p == *q)
14a: 0f b6 02 movzbl (%edx),%eax
14d: 84 c0 test %al,%al
14f: 74 2d je 17e <strcmp+0x3e>
151: 0f b6 19 movzbl (%ecx),%ebx
154: 38 d8 cmp %bl,%al
156: 74 0e je 166 <strcmp+0x26>
158: eb 2b jmp 185 <strcmp+0x45>
15a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
160: 38 c8 cmp %cl,%al
162: 75 15 jne 179 <strcmp+0x39>
p++, q++;
164: 89 d9 mov %ebx,%ecx
166: 83 c2 01 add $0x1,%edx
while(*p && *p == *q)
169: 0f b6 02 movzbl (%edx),%eax
p++, q++;
16c: 8d 59 01 lea 0x1(%ecx),%ebx
while(*p && *p == *q)
16f: 0f b6 49 01 movzbl 0x1(%ecx),%ecx
173: 84 c0 test %al,%al
175: 75 e9 jne 160 <strcmp+0x20>
177: 31 c0 xor %eax,%eax
return (uchar)*p - (uchar)*q;
179: 29 c8 sub %ecx,%eax
}
17b: 5b pop %ebx
17c: 5d pop %ebp
17d: c3 ret
17e: 0f b6 09 movzbl (%ecx),%ecx
while(*p && *p == *q)
181: 31 c0 xor %eax,%eax
183: eb f4 jmp 179 <strcmp+0x39>
185: 0f b6 cb movzbl %bl,%ecx
188: eb ef jmp 179 <strcmp+0x39>
18a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
00000190 <strlen>:
uint
strlen(const char *s)
{
190: 55 push %ebp
191: 89 e5 mov %esp,%ebp
193: 8b 4d 08 mov 0x8(%ebp),%ecx
int n;
for(n = 0; s[n]; n++)
196: 80 39 00 cmpb $0x0,(%ecx)
199: 74 12 je 1ad <strlen+0x1d>
19b: 31 d2 xor %edx,%edx
19d: 8d 76 00 lea 0x0(%esi),%esi
1a0: 83 c2 01 add $0x1,%edx
1a3: 80 3c 11 00 cmpb $0x0,(%ecx,%edx,1)
1a7: 89 d0 mov %edx,%eax
1a9: 75 f5 jne 1a0 <strlen+0x10>
;
return n;
}
1ab: 5d pop %ebp
1ac: c3 ret
for(n = 0; s[n]; n++)
1ad: 31 c0 xor %eax,%eax
}
1af: 5d pop %ebp
1b0: c3 ret
1b1: eb 0d jmp 1c0 <memset>
1b3: 90 nop
1b4: 90 nop
1b5: 90 nop
1b6: 90 nop
1b7: 90 nop
1b8: 90 nop
1b9: 90 nop
1ba: 90 nop
1bb: 90 nop
1bc: 90 nop
1bd: 90 nop
1be: 90 nop
1bf: 90 nop
000001c0 <memset>:
void*
memset(void *dst, int c, uint n)
{
1c0: 55 push %ebp
1c1: 89 e5 mov %esp,%ebp
1c3: 8b 55 08 mov 0x8(%ebp),%edx
1c6: 57 push %edi
}
static inline void
stosb(void *addr, int data, int cnt)
{
asm volatile("cld; rep stosb" :
1c7: 8b 4d 10 mov 0x10(%ebp),%ecx
1ca: 8b 45 0c mov 0xc(%ebp),%eax
1cd: 89 d7 mov %edx,%edi
1cf: fc cld
1d0: f3 aa rep stos %al,%es:(%edi)
stosb(dst, c, n);
return dst;
}
1d2: 89 d0 mov %edx,%eax
1d4: 5f pop %edi
1d5: 5d pop %ebp
1d6: c3 ret
1d7: 89 f6 mov %esi,%esi
1d9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
000001e0 <strchr>:
char*
strchr(const char *s, char c)
{
1e0: 55 push %ebp
1e1: 89 e5 mov %esp,%ebp
1e3: 8b 45 08 mov 0x8(%ebp),%eax
1e6: 53 push %ebx
1e7: 8b 55 0c mov 0xc(%ebp),%edx
for(; *s; s++)
1ea: 0f b6 18 movzbl (%eax),%ebx
1ed: 84 db test %bl,%bl
1ef: 74 1d je 20e <strchr+0x2e>
if(*s == c)
1f1: 38 d3 cmp %dl,%bl
1f3: 89 d1 mov %edx,%ecx
1f5: 75 0d jne 204 <strchr+0x24>
1f7: eb 17 jmp 210 <strchr+0x30>
1f9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
200: 38 ca cmp %cl,%dl
202: 74 0c je 210 <strchr+0x30>
for(; *s; s++)
204: 83 c0 01 add $0x1,%eax
207: 0f b6 10 movzbl (%eax),%edx
20a: 84 d2 test %dl,%dl
20c: 75 f2 jne 200 <strchr+0x20>
return (char*)s;
return 0;
20e: 31 c0 xor %eax,%eax
}
210: 5b pop %ebx
211: 5d pop %ebp
212: c3 ret
213: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
219: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
00000220 <gets>:
char*
gets(char *buf, int max)
{
220: 55 push %ebp
221: 89 e5 mov %esp,%ebp
223: 57 push %edi
224: 56 push %esi
int i, cc;
char c;
for(i=0; i+1 < max; ){
225: 31 f6 xor %esi,%esi
{
227: 53 push %ebx
228: 83 ec 2c sub $0x2c,%esp
cc = read(0, &c, 1);
22b: 8d 7d e7 lea -0x19(%ebp),%edi
for(i=0; i+1 < max; ){
22e: eb 31 jmp 261 <gets+0x41>
cc = read(0, &c, 1);
230: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp)
237: 00
238: 89 7c 24 04 mov %edi,0x4(%esp)
23c: c7 04 24 00 00 00 00 movl $0x0,(%esp)
243: e8 02 01 00 00 call 34a <read>
if(cc < 1)
248: 85 c0 test %eax,%eax
24a: 7e 1d jle 269 <gets+0x49>
break;
buf[i++] = c;
24c: 0f b6 45 e7 movzbl -0x19(%ebp),%eax
for(i=0; i+1 < max; ){
250: 89 de mov %ebx,%esi
buf[i++] = c;
252: 8b 55 08 mov 0x8(%ebp),%edx
if(c == '\n' || c == '\r')
255: 3c 0d cmp $0xd,%al
buf[i++] = c;
257: 88 44 1a ff mov %al,-0x1(%edx,%ebx,1)
if(c == '\n' || c == '\r')
25b: 74 0c je 269 <gets+0x49>
25d: 3c 0a cmp $0xa,%al
25f: 74 08 je 269 <gets+0x49>
for(i=0; i+1 < max; ){
261: 8d 5e 01 lea 0x1(%esi),%ebx
264: 3b 5d 0c cmp 0xc(%ebp),%ebx
267: 7c c7 jl 230 <gets+0x10>
break;
}
buf[i] = '\0';
269: 8b 45 08 mov 0x8(%ebp),%eax
26c: c6 04 30 00 movb $0x0,(%eax,%esi,1)
return buf;
}
270: 83 c4 2c add $0x2c,%esp
273: 5b pop %ebx
274: 5e pop %esi
275: 5f pop %edi
276: 5d pop %ebp
277: c3 ret
278: 90 nop
279: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
00000280 <stat>:
int
stat(const char *n, struct stat *st)
{
280: 55 push %ebp
281: 89 e5 mov %esp,%ebp
283: 56 push %esi
284: 53 push %ebx
285: 83 ec 10 sub $0x10,%esp
int fd;
int r;
fd = open(n, O_RDONLY);
288: 8b 45 08 mov 0x8(%ebp),%eax
28b: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
292: 00
293: 89 04 24 mov %eax,(%esp)
296: e8 d7 00 00 00 call 372 <open>
if(fd < 0)
29b: 85 c0 test %eax,%eax
fd = open(n, O_RDONLY);
29d: 89 c3 mov %eax,%ebx
if(fd < 0)
29f: 78 27 js 2c8 <stat+0x48>
return -1;
r = fstat(fd, st);
2a1: 8b 45 0c mov 0xc(%ebp),%eax
2a4: 89 1c 24 mov %ebx,(%esp)
2a7: 89 44 24 04 mov %eax,0x4(%esp)
2ab: e8 da 00 00 00 call 38a <fstat>
close(fd);
2b0: 89 1c 24 mov %ebx,(%esp)
r = fstat(fd, st);
2b3: 89 c6 mov %eax,%esi
close(fd);
2b5: e8 a0 00 00 00 call 35a <close>
return r;
2ba: 89 f0 mov %esi,%eax
}
2bc: 83 c4 10 add $0x10,%esp
2bf: 5b pop %ebx
2c0: 5e pop %esi
2c1: 5d pop %ebp
2c2: c3 ret
2c3: 90 nop
2c4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
return -1;
2c8: b8 ff ff ff ff mov $0xffffffff,%eax
2cd: eb ed jmp 2bc <stat+0x3c>
2cf: 90 nop
000002d0 <atoi>:
int
atoi(const char *s)
{
2d0: 55 push %ebp
2d1: 89 e5 mov %esp,%ebp
2d3: 8b 4d 08 mov 0x8(%ebp),%ecx
2d6: 53 push %ebx
int n;
n = 0;
while('0' <= *s && *s <= '9')
2d7: 0f be 11 movsbl (%ecx),%edx
2da: 8d 42 d0 lea -0x30(%edx),%eax
2dd: 3c 09 cmp $0x9,%al
n = 0;
2df: b8 00 00 00 00 mov $0x0,%eax
while('0' <= *s && *s <= '9')
2e4: 77 17 ja 2fd <atoi+0x2d>
2e6: 66 90 xchg %ax,%ax
n = n*10 + *s++ - '0';
2e8: 83 c1 01 add $0x1,%ecx
2eb: 8d 04 80 lea (%eax,%eax,4),%eax
2ee: 8d 44 42 d0 lea -0x30(%edx,%eax,2),%eax
while('0' <= *s && *s <= '9')
2f2: 0f be 11 movsbl (%ecx),%edx
2f5: 8d 5a d0 lea -0x30(%edx),%ebx
2f8: 80 fb 09 cmp $0x9,%bl
2fb: 76 eb jbe 2e8 <atoi+0x18>
return n;
}
2fd: 5b pop %ebx
2fe: 5d pop %ebp
2ff: c3 ret
00000300 <memmove>:
void*
memmove(void *vdst, const void *vsrc, int n)
{
300: 55 push %ebp
char *dst;
const char *src;
dst = vdst;
src = vsrc;
while(n-- > 0)
301: 31 d2 xor %edx,%edx
{
303: 89 e5 mov %esp,%ebp
305: 56 push %esi
306: 8b 45 08 mov 0x8(%ebp),%eax
309: 53 push %ebx
30a: 8b 5d 10 mov 0x10(%ebp),%ebx
30d: 8b 75 0c mov 0xc(%ebp),%esi
while(n-- > 0)
310: 85 db test %ebx,%ebx
312: 7e 12 jle 326 <memmove+0x26>
314: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
*dst++ = *src++;
318: 0f b6 0c 16 movzbl (%esi,%edx,1),%ecx
31c: 88 0c 10 mov %cl,(%eax,%edx,1)
31f: 83 c2 01 add $0x1,%edx
while(n-- > 0)
322: 39 da cmp %ebx,%edx
324: 75 f2 jne 318 <memmove+0x18>
return vdst;
}
326: 5b pop %ebx
327: 5e pop %esi
328: 5d pop %ebp
329: c3 ret
0000032a <fork>:
name: \
movl $SYS_ ## name, %eax; \
int $T_SYSCALL; \
ret
SYSCALL(fork)
32a: b8 01 00 00 00 mov $0x1,%eax
32f: cd 40 int $0x40
331: c3 ret
00000332 <exit>:
SYSCALL(exit)
332: b8 02 00 00 00 mov $0x2,%eax
337: cd 40 int $0x40
339: c3 ret
0000033a <wait>:
SYSCALL(wait)
33a: b8 03 00 00 00 mov $0x3,%eax
33f: cd 40 int $0x40
341: c3 ret
00000342 <pipe>:
SYSCALL(pipe)
342: b8 04 00 00 00 mov $0x4,%eax
347: cd 40 int $0x40
349: c3 ret
0000034a <read>:
SYSCALL(read)
34a: b8 05 00 00 00 mov $0x5,%eax
34f: cd 40 int $0x40
351: c3 ret
00000352 <write>:
SYSCALL(write)
352: b8 10 00 00 00 mov $0x10,%eax
357: cd 40 int $0x40
359: c3 ret
0000035a <close>:
SYSCALL(close)
35a: b8 15 00 00 00 mov $0x15,%eax
35f: cd 40 int $0x40
361: c3 ret
00000362 <kill>:
SYSCALL(kill)
362: b8 06 00 00 00 mov $0x6,%eax
367: cd 40 int $0x40
369: c3 ret
0000036a <exec>:
SYSCALL(exec)
36a: b8 07 00 00 00 mov $0x7,%eax
36f: cd 40 int $0x40
371: c3 ret
00000372 <open>:
SYSCALL(open)
372: b8 0f 00 00 00 mov $0xf,%eax
377: cd 40 int $0x40
379: c3 ret
0000037a <mknod>:
SYSCALL(mknod)
37a: b8 11 00 00 00 mov $0x11,%eax
37f: cd 40 int $0x40
381: c3 ret
00000382 <unlink>:
SYSCALL(unlink)
382: b8 12 00 00 00 mov $0x12,%eax
387: cd 40 int $0x40
389: c3 ret
0000038a <fstat>:
SYSCALL(fstat)
38a: b8 08 00 00 00 mov $0x8,%eax
38f: cd 40 int $0x40
391: c3 ret
00000392 <link>:
SYSCALL(link)
392: b8 13 00 00 00 mov $0x13,%eax
397: cd 40 int $0x40
399: c3 ret
0000039a <mkdir>:
SYSCALL(mkdir)
39a: b8 14 00 00 00 mov $0x14,%eax
39f: cd 40 int $0x40
3a1: c3 ret
000003a2 <chdir>:
SYSCALL(chdir)
3a2: b8 09 00 00 00 mov $0x9,%eax
3a7: cd 40 int $0x40
3a9: c3 ret
000003aa <dup>:
SYSCALL(dup)
3aa: b8 0a 00 00 00 mov $0xa,%eax
3af: cd 40 int $0x40
3b1: c3 ret
000003b2 <getpid>:
SYSCALL(getpid)
3b2: b8 0b 00 00 00 mov $0xb,%eax
3b7: cd 40 int $0x40
3b9: c3 ret
000003ba <sbrk>:
SYSCALL(sbrk)
3ba: b8 0c 00 00 00 mov $0xc,%eax
3bf: cd 40 int $0x40
3c1: c3 ret
000003c2 <sleep>:
SYSCALL(sleep)
3c2: b8 0d 00 00 00 mov $0xd,%eax
3c7: cd 40 int $0x40
3c9: c3 ret
000003ca <uptime>:
SYSCALL(uptime)
3ca: b8 0e 00 00 00 mov $0xe,%eax
3cf: cd 40 int $0x40
3d1: c3 ret
000003d2 <exitS>:
SYSCALL(exitS)
3d2: b8 16 00 00 00 mov $0x16,%eax
3d7: cd 40 int $0x40
3d9: c3 ret
000003da <waitpid>:
SYSCALL(waitpid)
3da: b8 17 00 00 00 mov $0x17,%eax
3df: cd 40 int $0x40
3e1: c3 ret
000003e2 <set_prior>:
SYSCALL(set_prior)
3e2: b8 18 00 00 00 mov $0x18,%eax
3e7: cd 40 int $0x40
3e9: c3 ret
3ea: 66 90 xchg %ax,%ax
3ec: 66 90 xchg %ax,%ax
3ee: 66 90 xchg %ax,%ax
000003f0 <printint>:
write(fd, &c, 1);
}
static void
printint(int fd, int xx, int base, int sgn)
{
3f0: 55 push %ebp
3f1: 89 e5 mov %esp,%ebp
3f3: 57 push %edi
3f4: 56 push %esi
3f5: 89 c6 mov %eax,%esi
3f7: 53 push %ebx
3f8: 83 ec 4c sub $0x4c,%esp
char buf[16];
int i, neg;
uint x;
neg = 0;
if(sgn && xx < 0){
3fb: 8b 5d 08 mov 0x8(%ebp),%ebx
3fe: 85 db test %ebx,%ebx
400: 74 09 je 40b <printint+0x1b>
402: 89 d0 mov %edx,%eax
404: c1 e8 1f shr $0x1f,%eax
407: 84 c0 test %al,%al
409: 75 75 jne 480 <printint+0x90>
neg = 1;
x = -xx;
} else {
x = xx;
40b: 89 d0 mov %edx,%eax
neg = 0;
40d: c7 45 c4 00 00 00 00 movl $0x0,-0x3c(%ebp)
414: 89 75 c0 mov %esi,-0x40(%ebp)
}
i = 0;
417: 31 ff xor %edi,%edi
419: 89 ce mov %ecx,%esi
41b: 8d 5d d7 lea -0x29(%ebp),%ebx
41e: eb 02 jmp 422 <printint+0x32>
do{
buf[i++] = digits[x % base];
420: 89 cf mov %ecx,%edi
422: 31 d2 xor %edx,%edx
424: f7 f6 div %esi
426: 8d 4f 01 lea 0x1(%edi),%ecx
429: 0f b6 92 4d 08 00 00 movzbl 0x84d(%edx),%edx
}while((x /= base) != 0);
430: 85 c0 test %eax,%eax
buf[i++] = digits[x % base];
432: 88 14 0b mov %dl,(%ebx,%ecx,1)
}while((x /= base) != 0);
435: 75 e9 jne 420 <printint+0x30>
if(neg)
437: 8b 55 c4 mov -0x3c(%ebp),%edx
buf[i++] = digits[x % base];
43a: 89 c8 mov %ecx,%eax
43c: 8b 75 c0 mov -0x40(%ebp),%esi
if(neg)
43f: 85 d2 test %edx,%edx
441: 74 08 je 44b <printint+0x5b>
buf[i++] = '-';
443: 8d 4f 02 lea 0x2(%edi),%ecx
446: c6 44 05 d8 2d movb $0x2d,-0x28(%ebp,%eax,1)
while(--i >= 0)
44b: 8d 79 ff lea -0x1(%ecx),%edi
44e: 66 90 xchg %ax,%ax
450: 0f b6 44 3d d8 movzbl -0x28(%ebp,%edi,1),%eax
455: 83 ef 01 sub $0x1,%edi
write(fd, &c, 1);
458: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp)
45f: 00
460: 89 5c 24 04 mov %ebx,0x4(%esp)
464: 89 34 24 mov %esi,(%esp)
467: 88 45 d7 mov %al,-0x29(%ebp)
46a: e8 e3 fe ff ff call 352 <write>
while(--i >= 0)
46f: 83 ff ff cmp $0xffffffff,%edi
472: 75 dc jne 450 <printint+0x60>
putc(fd, buf[i]);
}
474: 83 c4 4c add $0x4c,%esp
477: 5b pop %ebx
478: 5e pop %esi
479: 5f pop %edi
47a: 5d pop %ebp
47b: c3 ret
47c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
x = -xx;
480: 89 d0 mov %edx,%eax
482: f7 d8 neg %eax
neg = 1;
484: c7 45 c4 01 00 00 00 movl $0x1,-0x3c(%ebp)
48b: eb 87 jmp 414 <printint+0x24>
48d: 8d 76 00 lea 0x0(%esi),%esi
00000490 <printf>:
// Print to the given fd. Only understands %d, %x, %p, %s.
void
printf(int fd, const char *fmt, ...)
{
490: 55 push %ebp
491: 89 e5 mov %esp,%ebp
493: 57 push %edi
char *s;
int c, i, state;
uint *ap;
state = 0;
494: 31 ff xor %edi,%edi
{
496: 56 push %esi
497: 53 push %ebx
498: 83 ec 3c sub $0x3c,%esp
ap = (uint*)(void*)&fmt + 1;
for(i = 0; fmt[i]; i++){
49b: 8b 5d 0c mov 0xc(%ebp),%ebx
ap = (uint*)(void*)&fmt + 1;
49e: 8d 45 10 lea 0x10(%ebp),%eax
{
4a1: 8b 75 08 mov 0x8(%ebp),%esi
ap = (uint*)(void*)&fmt + 1;
4a4: 89 45 d4 mov %eax,-0x2c(%ebp)
for(i = 0; fmt[i]; i++){
4a7: 0f b6 13 movzbl (%ebx),%edx
4aa: 83 c3 01 add $0x1,%ebx
4ad: 84 d2 test %dl,%dl
4af: 75 39 jne 4ea <printf+0x5a>
4b1: e9 c2 00 00 00 jmp 578 <printf+0xe8>
4b6: 66 90 xchg %ax,%ax
c = fmt[i] & 0xff;
if(state == 0){
if(c == '%'){
4b8: 83 fa 25 cmp $0x25,%edx
4bb: 0f 84 bf 00 00 00 je 580 <printf+0xf0>
write(fd, &c, 1);
4c1: 8d 45 e2 lea -0x1e(%ebp),%eax
4c4: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp)
4cb: 00
4cc: 89 44 24 04 mov %eax,0x4(%esp)
4d0: 89 34 24 mov %esi,(%esp)
state = '%';
} else {
putc(fd, c);
4d3: 88 55 e2 mov %dl,-0x1e(%ebp)
write(fd, &c, 1);
4d6: e8 77 fe ff ff call 352 <write>
4db: 83 c3 01 add $0x1,%ebx
for(i = 0; fmt[i]; i++){
4de: 0f b6 53 ff movzbl -0x1(%ebx),%edx
4e2: 84 d2 test %dl,%dl
4e4: 0f 84 8e 00 00 00 je 578 <printf+0xe8>
if(state == 0){
4ea: 85 ff test %edi,%edi
c = fmt[i] & 0xff;
4ec: 0f be c2 movsbl %dl,%eax
if(state == 0){
4ef: 74 c7 je 4b8 <printf+0x28>
}
} else if(state == '%'){
4f1: 83 ff 25 cmp $0x25,%edi
4f4: 75 e5 jne 4db <printf+0x4b>
if(c == 'd'){
4f6: 83 fa 64 cmp $0x64,%edx
4f9: 0f 84 31 01 00 00 je 630 <printf+0x1a0>
printint(fd, *ap, 10, 1);
ap++;
} else if(c == 'x' || c == 'p'){
4ff: 25 f7 00 00 00 and $0xf7,%eax
504: 83 f8 70 cmp $0x70,%eax
507: 0f 84 83 00 00 00 je 590 <printf+0x100>
printint(fd, *ap, 16, 0);
ap++;
} else if(c == 's'){
50d: 83 fa 73 cmp $0x73,%edx
510: 0f 84 a2 00 00 00 je 5b8 <printf+0x128>
s = "(null)";
while(*s != 0){
putc(fd, *s);
s++;
}
} else if(c == 'c'){
516: 83 fa 63 cmp $0x63,%edx
519: 0f 84 35 01 00 00 je 654 <printf+0x1c4>
putc(fd, *ap);
ap++;
} else if(c == '%'){
51f: 83 fa 25 cmp $0x25,%edx
522: 0f 84 e0 00 00 00 je 608 <printf+0x178>
write(fd, &c, 1);
528: 8d 45 e6 lea -0x1a(%ebp),%eax
52b: 83 c3 01 add $0x1,%ebx
52e: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp)
535: 00
} else {
// Unknown % sequence. Print it to draw attention.
putc(fd, '%');
putc(fd, c);
}
state = 0;
536: 31 ff xor %edi,%edi
write(fd, &c, 1);
538: 89 44 24 04 mov %eax,0x4(%esp)
53c: 89 34 24 mov %esi,(%esp)
53f: 89 55 d0 mov %edx,-0x30(%ebp)
542: c6 45 e6 25 movb $0x25,-0x1a(%ebp)
546: e8 07 fe ff ff call 352 <write>
putc(fd, c);
54b: 8b 55 d0 mov -0x30(%ebp),%edx
write(fd, &c, 1);
54e: 8d 45 e7 lea -0x19(%ebp),%eax
551: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp)
558: 00
559: 89 44 24 04 mov %eax,0x4(%esp)
55d: 89 34 24 mov %esi,(%esp)
putc(fd, c);
560: 88 55 e7 mov %dl,-0x19(%ebp)
write(fd, &c, 1);
563: e8 ea fd ff ff call 352 <write>
for(i = 0; fmt[i]; i++){
568: 0f b6 53 ff movzbl -0x1(%ebx),%edx
56c: 84 d2 test %dl,%dl
56e: 0f 85 76 ff ff ff jne 4ea <printf+0x5a>
574: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
}
}
}
578: 83 c4 3c add $0x3c,%esp
57b: 5b pop %ebx
57c: 5e pop %esi
57d: 5f pop %edi
57e: 5d pop %ebp
57f: c3 ret
state = '%';
580: bf 25 00 00 00 mov $0x25,%edi
585: e9 51 ff ff ff jmp 4db <printf+0x4b>
58a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
printint(fd, *ap, 16, 0);
590: 8b 45 d4 mov -0x2c(%ebp),%eax
593: b9 10 00 00 00 mov $0x10,%ecx
state = 0;
598: 31 ff xor %edi,%edi
printint(fd, *ap, 16, 0);
59a: c7 04 24 00 00 00 00 movl $0x0,(%esp)
5a1: 8b 10 mov (%eax),%edx
5a3: 89 f0 mov %esi,%eax
5a5: e8 46 fe ff ff call 3f0 <printint>
ap++;
5aa: 83 45 d4 04 addl $0x4,-0x2c(%ebp)
5ae: e9 28 ff ff ff jmp 4db <printf+0x4b>
5b3: 90 nop
5b4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
s = (char*)*ap;
5b8: 8b 45 d4 mov -0x2c(%ebp),%eax
ap++;
5bb: 83 45 d4 04 addl $0x4,-0x2c(%ebp)
s = (char*)*ap;
5bf: 8b 38 mov (%eax),%edi
s = "(null)";
5c1: b8 46 08 00 00 mov $0x846,%eax
5c6: 85 ff test %edi,%edi
5c8: 0f 44 f8 cmove %eax,%edi
while(*s != 0){
5cb: 0f b6 07 movzbl (%edi),%eax
5ce: 84 c0 test %al,%al
5d0: 74 2a je 5fc <printf+0x16c>
5d2: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
5d8: 88 45 e3 mov %al,-0x1d(%ebp)
write(fd, &c, 1);
5db: 8d 45 e3 lea -0x1d(%ebp),%eax
s++;
5de: 83 c7 01 add $0x1,%edi
write(fd, &c, 1);
5e1: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp)
5e8: 00
5e9: 89 44 24 04 mov %eax,0x4(%esp)
5ed: 89 34 24 mov %esi,(%esp)
5f0: e8 5d fd ff ff call 352 <write>
while(*s != 0){
5f5: 0f b6 07 movzbl (%edi),%eax
5f8: 84 c0 test %al,%al
5fa: 75 dc jne 5d8 <printf+0x148>
state = 0;
5fc: 31 ff xor %edi,%edi
5fe: e9 d8 fe ff ff jmp 4db <printf+0x4b>
603: 90 nop
604: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
write(fd, &c, 1);
608: 8d 45 e5 lea -0x1b(%ebp),%eax
state = 0;
60b: 31 ff xor %edi,%edi
write(fd, &c, 1);
60d: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp)
614: 00
615: 89 44 24 04 mov %eax,0x4(%esp)
619: 89 34 24 mov %esi,(%esp)
61c: c6 45 e5 25 movb $0x25,-0x1b(%ebp)
620: e8 2d fd ff ff call 352 <write>
625: e9 b1 fe ff ff jmp 4db <printf+0x4b>
62a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
printint(fd, *ap, 10, 1);
630: 8b 45 d4 mov -0x2c(%ebp),%eax
633: b9 0a 00 00 00 mov $0xa,%ecx
state = 0;
638: 66 31 ff xor %di,%di
printint(fd, *ap, 10, 1);
63b: c7 04 24 01 00 00 00 movl $0x1,(%esp)
642: 8b 10 mov (%eax),%edx
644: 89 f0 mov %esi,%eax
646: e8 a5 fd ff ff call 3f0 <printint>
ap++;
64b: 83 45 d4 04 addl $0x4,-0x2c(%ebp)
64f: e9 87 fe ff ff jmp 4db <printf+0x4b>
putc(fd, *ap);
654: 8b 45 d4 mov -0x2c(%ebp),%eax
state = 0;
657: 31 ff xor %edi,%edi
putc(fd, *ap);
659: 8b 00 mov (%eax),%eax
write(fd, &c, 1);
65b: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp)
662: 00
663: 89 34 24 mov %esi,(%esp)
putc(fd, *ap);
666: 88 45 e4 mov %al,-0x1c(%ebp)
write(fd, &c, 1);
669: 8d 45 e4 lea -0x1c(%ebp),%eax
66c: 89 44 24 04 mov %eax,0x4(%esp)
670: e8 dd fc ff ff call 352 <write>
ap++;
675: 83 45 d4 04 addl $0x4,-0x2c(%ebp)
679: e9 5d fe ff ff jmp 4db <printf+0x4b>
67e: 66 90 xchg %ax,%ax
00000680 <free>:
static Header base;
static Header *freep;
void
free(void *ap)
{
680: 55 push %ebp
Header *bp, *p;
bp = (Header*)ap - 1;
for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
681: a1 cc 0a 00 00 mov 0xacc,%eax
{
686: 89 e5 mov %esp,%ebp
688: 57 push %edi
689: 56 push %esi
68a: 53 push %ebx
68b: 8b 5d 08 mov 0x8(%ebp),%ebx
if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
68e: 8b 08 mov (%eax),%ecx
bp = (Header*)ap - 1;
690: 8d 53 f8 lea -0x8(%ebx),%edx
for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
693: 39 d0 cmp %edx,%eax
695: 72 11 jb 6a8 <free+0x28>
697: 90 nop
if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
698: 39 c8 cmp %ecx,%eax
69a: 72 04 jb 6a0 <free+0x20>
69c: 39 ca cmp %ecx,%edx
69e: 72 10 jb 6b0 <free+0x30>
6a0: 89 c8 mov %ecx,%eax
for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
6a2: 39 d0 cmp %edx,%eax
if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
6a4: 8b 08 mov (%eax),%ecx
for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
6a6: 73 f0 jae 698 <free+0x18>
6a8: 39 ca cmp %ecx,%edx
6aa: 72 04 jb 6b0 <free+0x30>
if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
6ac: 39 c8 cmp %ecx,%eax
6ae: 72 f0 jb 6a0 <free+0x20>
break;
if(bp + bp->s.size == p->s.ptr){
6b0: 8b 73 fc mov -0x4(%ebx),%esi
6b3: 8d 3c f2 lea (%edx,%esi,8),%edi
6b6: 39 cf cmp %ecx,%edi
6b8: 74 1e je 6d8 <free+0x58>
bp->s.size += p->s.ptr->s.size;
bp->s.ptr = p->s.ptr->s.ptr;
} else
bp->s.ptr = p->s.ptr;
6ba: 89 4b f8 mov %ecx,-0x8(%ebx)
if(p + p->s.size == bp){
6bd: 8b 48 04 mov 0x4(%eax),%ecx
6c0: 8d 34 c8 lea (%eax,%ecx,8),%esi
6c3: 39 f2 cmp %esi,%edx
6c5: 74 28 je 6ef <free+0x6f>
p->s.size += bp->s.size;
p->s.ptr = bp->s.ptr;
} else
p->s.ptr = bp;
6c7: 89 10 mov %edx,(%eax)
freep = p;
6c9: a3 cc 0a 00 00 mov %eax,0xacc
}
6ce: 5b pop %ebx
6cf: 5e pop %esi
6d0: 5f pop %edi
6d1: 5d pop %ebp
6d2: c3 ret
6d3: 90 nop
6d4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
bp->s.size += p->s.ptr->s.size;
6d8: 03 71 04 add 0x4(%ecx),%esi
6db: 89 73 fc mov %esi,-0x4(%ebx)
bp->s.ptr = p->s.ptr->s.ptr;
6de: 8b 08 mov (%eax),%ecx
6e0: 8b 09 mov (%ecx),%ecx
6e2: 89 4b f8 mov %ecx,-0x8(%ebx)
if(p + p->s.size == bp){
6e5: 8b 48 04 mov 0x4(%eax),%ecx
6e8: 8d 34 c8 lea (%eax,%ecx,8),%esi
6eb: 39 f2 cmp %esi,%edx
6ed: 75 d8 jne 6c7 <free+0x47>
p->s.size += bp->s.size;
6ef: 03 4b fc add -0x4(%ebx),%ecx
freep = p;
6f2: a3 cc 0a 00 00 mov %eax,0xacc
p->s.size += bp->s.size;
6f7: 89 48 04 mov %ecx,0x4(%eax)
p->s.ptr = bp->s.ptr;
6fa: 8b 53 f8 mov -0x8(%ebx),%edx
6fd: 89 10 mov %edx,(%eax)
}
6ff: 5b pop %ebx
700: 5e pop %esi
701: 5f pop %edi
702: 5d pop %ebp
703: c3 ret
704: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
70a: 8d bf 00 00 00 00 lea 0x0(%edi),%edi
00000710 <malloc>:
return freep;
}
void*
malloc(uint nbytes)
{
710: 55 push %ebp
711: 89 e5 mov %esp,%ebp
713: 57 push %edi
714: 56 push %esi
715: 53 push %ebx
716: 83 ec 1c sub $0x1c,%esp
Header *p, *prevp;
uint nunits;
nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
719: 8b 45 08 mov 0x8(%ebp),%eax
if((prevp = freep) == 0){
71c: 8b 1d cc 0a 00 00 mov 0xacc,%ebx
nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
722: 8d 48 07 lea 0x7(%eax),%ecx
725: c1 e9 03 shr $0x3,%ecx
if((prevp = freep) == 0){
728: 85 db test %ebx,%ebx
nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
72a: 8d 71 01 lea 0x1(%ecx),%esi
if((prevp = freep) == 0){
72d: 0f 84 9b 00 00 00 je 7ce <malloc+0xbe>
733: 8b 13 mov (%ebx),%edx
735: 8b 7a 04 mov 0x4(%edx),%edi
base.s.ptr = freep = prevp = &base;
base.s.size = 0;
}
for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
if(p->s.size >= nunits){
738: 39 fe cmp %edi,%esi
73a: 76 64 jbe 7a0 <malloc+0x90>
73c: 8d 04 f5 00 00 00 00 lea 0x0(,%esi,8),%eax
if(nu < 4096)
743: bb 00 80 00 00 mov $0x8000,%ebx
748: 89 45 e4 mov %eax,-0x1c(%ebp)
74b: eb 0e jmp 75b <malloc+0x4b>
74d: 8d 76 00 lea 0x0(%esi),%esi
for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
750: 8b 02 mov (%edx),%eax
if(p->s.size >= nunits){
752: 8b 78 04 mov 0x4(%eax),%edi
755: 39 fe cmp %edi,%esi
757: 76 4f jbe 7a8 <malloc+0x98>
759: 89 c2 mov %eax,%edx
p->s.size = nunits;
}
freep = prevp;
return (void*)(p + 1);
}
if(p == freep)
75b: 3b 15 cc 0a 00 00 cmp 0xacc,%edx
761: 75 ed jne 750 <malloc+0x40>
if(nu < 4096)
763: 8b 45 e4 mov -0x1c(%ebp),%eax
766: 81 fe 00 10 00 00 cmp $0x1000,%esi
76c: bf 00 10 00 00 mov $0x1000,%edi
771: 0f 43 fe cmovae %esi,%edi
774: 0f 42 c3 cmovb %ebx,%eax
p = sbrk(nu * sizeof(Header));
777: 89 04 24 mov %eax,(%esp)
77a: e8 3b fc ff ff call 3ba <sbrk>
if(p == (char*)-1)
77f: 83 f8 ff cmp $0xffffffff,%eax
782: 74 18 je 79c <malloc+0x8c>
hp->s.size = nu;
784: 89 78 04 mov %edi,0x4(%eax)
free((void*)(hp + 1));
787: 83 c0 08 add $0x8,%eax
78a: 89 04 24 mov %eax,(%esp)
78d: e8 ee fe ff ff call 680 <free>
return freep;
792: 8b 15 cc 0a 00 00 mov 0xacc,%edx
if((p = morecore(nunits)) == 0)
798: 85 d2 test %edx,%edx
79a: 75 b4 jne 750 <malloc+0x40>
return 0;
79c: 31 c0 xor %eax,%eax
79e: eb 20 jmp 7c0 <malloc+0xb0>
if(p->s.size >= nunits){
7a0: 89 d0 mov %edx,%eax
7a2: 89 da mov %ebx,%edx
7a4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
if(p->s.size == nunits)
7a8: 39 fe cmp %edi,%esi
7aa: 74 1c je 7c8 <malloc+0xb8>
p->s.size -= nunits;
7ac: 29 f7 sub %esi,%edi
7ae: 89 78 04 mov %edi,0x4(%eax)
p += p->s.size;
7b1: 8d 04 f8 lea (%eax,%edi,8),%eax
p->s.size = nunits;
7b4: 89 70 04 mov %esi,0x4(%eax)
freep = prevp;
7b7: 89 15 cc 0a 00 00 mov %edx,0xacc
return (void*)(p + 1);
7bd: 83 c0 08 add $0x8,%eax
}
}
7c0: 83 c4 1c add $0x1c,%esp
7c3: 5b pop %ebx
7c4: 5e pop %esi
7c5: 5f pop %edi
7c6: 5d pop %ebp
7c7: c3 ret
prevp->s.ptr = p->s.ptr;
7c8: 8b 08 mov (%eax),%ecx
7ca: 89 0a mov %ecx,(%edx)
7cc: eb e9 jmp 7b7 <malloc+0xa7>
base.s.ptr = freep = prevp = &base;
7ce: c7 05 cc 0a 00 00 d0 movl $0xad0,0xacc
7d5: 0a 00 00
base.s.size = 0;
7d8: ba d0 0a 00 00 mov $0xad0,%edx
base.s.ptr = freep = prevp = &base;
7dd: c7 05 d0 0a 00 00 d0 movl $0xad0,0xad0
7e4: 0a 00 00
base.s.size = 0;
7e7: c7 05 d4 0a 00 00 00 movl $0x0,0xad4
7ee: 00 00 00
7f1: e9 46 ff ff ff jmp 73c <malloc+0x2c>
|
SECTION code_l
PUBLIC l_lsl_hl
INCLUDE "clib_cfg.asm"
; logical shift left 16-bit number
;
; enter : hl = 16-bit number
; a = shift amount
;
; exit : hl = hl << a
;
; uses : af, b, hl
IF __CLIB_OPT_IMATH_SELECT & $04
EXTERN l_fast_lsl_hl
defc l_lsl_hl = l_fast_lsl_hl
ELSE
EXTERN l_small_lsl_hl
defc l_lsl_hl = l_small_lsl_hl
ENDIF
|
;
; Startup for Microbee in BASIC mode
; RUNM "program"
;
; Stefano Bodrato - 2016
;
; If an error occurs eg break we just drop back to BASIC
;
; $Id: bee_crt0.asm,v 1.1 2016-11-15 08:11:10 stefano Exp $
;
MODULE bee_crt0
;--------
; Include zcc_opt.def to find out some info
;--------
defc crt0 = 1
INCLUDE "zcc_opt.def"
;--------
; Some scope definitions
;--------
EXTERN _main ;main() is always external to crt0 code
PUBLIC cleanup ;jp'd to by exit()
PUBLIC l_dcal ;jp(hl)
defc CONSOLE_COLUMNS = 80
defc CONSOLE_ROWS = 25
IF !DEFINED_CRT_ORG_CODE
defc CRT_ORG_CODE = $900 ; clean binary block
ENDIF
defc TAR__no_ansifont = 1
defc TAR__clib_exit_stack_size = 32
defc TAR__register_sp = -1
defc __CPU_CLOCK = 2000000
INCLUDE "crt/classic/crt_rules.inc"
org CRT_ORG_CODE
start:
ld (start1+1),sp
INCLUDE "crt/classic/crt_init_sp.asm"
INCLUDE "crt/classic/crt_init_atexit.asm"
call crt0_init_bss
ld (exitsp),sp
; Optional definition for auto MALLOC init
; it assumes we have free space between the end of
; the compiled program and the stack pointer
IF DEFINED_USING_amalloc
INCLUDE "crt/classic/crt_init_amalloc.asm"
ENDIF
call _main
cleanup:
LD HL,vdutab
LD C,0
LD B,16
.vdloop
LD A,C
OUT ($0C),A
LD A,(HL)
OUT ($0D),A
INC HL
INC C
DJNZ vdloop
;
; Deallocate memory which has been allocated here!
;
; push hl
call crt0_exit
; pop bc
start1:
ld sp,0
ret
l_dcal:
jp (hl)
.vdutab ; 64*16
defb 107,64,81,55,18,9,16,17,$48,$0F,$2F,$0F,0,0,0,0
INCLUDE "crt/classic/crt_runtime_selection.asm"
INCLUDE "crt/classic/crt_section.asm"
SECTION code_crt_init
nop
;ld hl,$
;ld (base_graphics),hl
|
; send sendet eine 64er-File über den Userport an
; den Amiga
; (Centronics-Routinen)
;------------------------------
;include 'HardwareVectoren.sub'
;------------------------------
;Hardware IO
vic = $d000
sid = $d400
colram = $d800
cia1 = $dc00
cia2 = $dd00
;CIA Register Offsets
cia_pra = 0 ;Port A
cia_prb = 1 ;Port B
cia_ddra = 2 ;Port A Richtungsregister 0-Ein 1-Aus
cia_ddrb = 3 ;Port B Richtungsregister 0-Ein 1-Aus
cia_ta = 4 ;Timer A, low, hi
cia_tb = 6 ;Timer B, low, hi
cia_tod = 8 ;TimeOfDay 10tel, sec, min, hr
cia_sdr = 12 ;Serial Data Register
cia_icr = 13 ;Interrupt Control Register
cia_cra = 14 ;Control Register a
cia_crb = 15 ;Control Register b
cia_flag = %00010000
;Einsprünge im Kernel
resvid = $ff81 ;Video-Reset
rescia = $ff84 ;CIA initialisieren
resram = $ff87 ;RAM löschen/testen
resio = $ff8a ;IO initialisieren
resiov = $ff8d ;IO-Vektoren initialisieren
setstatus = $ff90 ;status setzten
seclisten = $ff93 ;Sekundäradresse nach listen
sectalk = $ff96 ;Sekundäradresse nach talk
ramend = $ff99 ;RAM-Ende setzen/holen
ramstart = $ff9c ;RAM-Anfang setzen/holen
checkkey = $ff9f ;Tastatur abfragen
iectimeout = $ffa2 ;IEC Timeout-Flag setzen
iecin = $ffa5 ;Eingabe vom IEC-Bus
iecout = $ffa8 ;Ausgabe auf IEC-Bus
iecuntalk = $ffab ;UNTALK senden
iecunlisten = $ffae ;UNLISTEN senden
ieclisten = $ffb1 ;LISTEN senden
iectalk = $ffb4 ;TALK senden
getstatus = $ffb7 ;status holen, im Akku
setfls = $ffba ;Fileparameter setzten,
;a-filenr, x-gerätenr, y-sekundäradr
setnam = $ffbd ;Filenamenparameter setzten
;a-länge x-low y-hi
open = $ffc0 ;clc ->ok sec->error (Fortg. S.181)
close = $ffc3
chkin = $ffc6 ;Eingabegerät setzten, x=Kanal
ckout = $ffc9 ;Ausgabegrät setzen, x=Kanal
clrch = $ffcc ;Ein/Ausgabe rücksetzen, immer eq
input = $ffcf ;Eingabe eines Zeichens
print = $ffd2 ;Ausgabe eines Zeichens
load = $ffd5
save = $ffd8
settime = $ffdb ;Time setzen
gettime = $ffde ;Time holen
checkstop = $ffe1 ;Stop-Taste abfragen eq->stop
get = $ffe4
clall = $ffe7
inctime = $ffea ;Time erhöhen
getscreen = $ffed ;Anzahl der Zeilen/Spalten holen
setcursor = $fff0 ;Cursor setzen(clc)/holen(sec) x/y
getio = $fff3 ;Startadresse des IO-Bausteins holen
saveregister = $e147 ;SYS-Befehl: Register abspeichern
resscr = $e518 ;reset Bildschirm/Tastatur
clrscr = $e544 ;Bildschirm löschen
crsrhome = $e566 ;Cursor home
calccrsr = $e56c ;Cursorposition berechnen
initvid = $e5a0 ;Videocontroller mit Standard
getkey = $e5b4 ;Zeichen aus Tastaturpuffer
waitkey = $e5ca ;wartet auf Tastatureingabe
printscreen = $e716 ;Zeichen auf Bildschirm ausgeben
scrollup = $e8ea ;Scrollt Bildschirm nach oben
clrline = $e9ff ;löscht einen Zeile
putchar = $ea1c ;setzt Zeichen a-Bildschirmcode x-Farbe
;Basic-Routinen
strin = $a560 ;holt Zeile nach $200
strout = $ab1e ;a-lo y-hi
errorout = $a437 ;Basic-Warmstart Errornummer in a
uintout = $bdcd ;Ausgabe von uint in lo-X/hi-A
;Numerische Routinen aus der Basiczeile (Anfänger 155)
getbyt = $b79e
frmnum = $ad8a
getadr = $b7f7
chkcom = $aefd
chrgot = $0079
chrget = $0073
getpar = $b7eb
frmevl = $ad9e ;allgemeine Formelauswertung (Intern 87)
;(Fortgeschrittene)
;Fließkomma-Routinen
;wandlungen
ascfloat = $bcf3 ;lo-$7a hi-$7b jsr chrgot, dann round
round = $bc1b ;nach Wandlung runden
float2int = $bc9b ;hi$62-$65, wenn exp($61)<$a0
float2asc = $bddd ;legt ASCII-Zahl ab $100 ab a-lo y-hi
byte2fl = $bc3c ;a-byte
ubyte2fl = $b3a2 ;y-byte
word2fl = $b395 ;y-lo a-hi
uword2fl = $bc49 ;$63-lo $62-hi x-#$90 sec
lword2fl = $bc4f ;siehe Fort Seite 26
ulword2fl = $bc4f ;sec a-#0 x-#$a0 hi$62-$65
;Rechnen
argtofac = $bbfc
factoarg = $bc0c
flplus = $b86a ;FAC=ARG+FAC
flminus = $b853 ;FAC=ARG-FAC
flmul = $ba28 ;FAC=ARG*FAC
fldiv = $bb12 ;FAC=ARG/FAC
flpot = $bf7b ;FAC=ARG^FAC
;----------------------------------------------------------
;Systemkonstanten (nach 'The Commodore 64 Marco-Assembler')
; Zeropage und anderes
;----------------------------------------------------------
txttab = $2b ;Zeiger auf Basic-Prgrammstart
vartab = $2d ;Zeiger auf Start der Variablen
arytab = $2f ;Zeiger auf Start der Arrays
strend = $31 ;Zeiger auf Ende der Arrays
fretop = $33 ;Zeiger auf Start der Strings
facexp = $61 ;Fließkommaakku 1 Exponent
facho = $62 ; -$65 Mantisse
facsgn = $66 ; Vorzeichen
argexp = $69 ;Fließkommaakku 2 Exponent
argho = $9a ; -$9d Mantisse
argsgn = $9e ; Vorzeichen
direct_mode = $9d ;Flag für Direktmodus $80, Programm $00
tape_checksum1 = $9e ;Checksumme für Band Pass1
tape_checksum2 = $9f ;Fehlerkorrektur für Band Pass2
pointer1 = $fb ;$fb/$fc
pointer2 = $fd ;$fd/$fe
ascbuffer = $100
stack = $100 ;Prozessorstack
inputbuffer = $200 ;BASIC Eingabepuffer
sareg = $30c ;Akku für SYS-Befehl
sxreg = $30d ;x-Register
syreg = $30e ;y-Register
spreg = $30f ;Status-Register
irq_vector = $314 ;IRQ-Vektor
brk_vector = $316 ;Break-Vektor
;----------------------------
; Ende 'HardwareVectoren.sub'
;----------------------------
*= $c000
;*************************************************************************
;Protokoll:
; Filename,0,Bytes lo,Bytes hi,data...,checksum(lo,hi,data),weitere=255/0
;*************************************************************************
jmp startsend ;SYS12*4096
;Files vom Amiga empfangen
startreceive lda #<textreceive ;SYS12*4096+3
ldy #>textreceive
jsr strout ;Begrüßungstext
lda #<wartefiletext ;Warte auf File-Text
ldy #>wartefiletext
jsr strout
jsr syncin ;Syncronisieren
ldx #-1
wartename inx
jsr centrin ;hole den filenamen
sta inputbuffer,x
bne wartename
lda #<filenametext ;Text ausgeben
ldy #>filenametext
jsr strout
lda #<inputbuffer ;Filenamen ausgeben
ldy #>inputbuffer
jsr strout
jsr centrin ;Länge lo
sta pointer1
jsr startchecksum
jsr centrin ;Länge hi
sta pointer1+1
jsr checksum
jsr showlen
jsr openfile ;File öffnen
lda #<laeufttext ;Empfangsmeldung
ldy #>laeufttext ; ausgeben
jsr strout
holefile sec ;Schleifenzähler
lda pointer1 ;lo-Byte
sbc #1 ;dekrementieren
sta pointer1
bcs keinuebertrag
lda pointer1+1 ;auch hi-Byte
sbc #0 ;dekrementieren
sta pointer1+1
bcc endholefile ;bei Null ende
lda #'. ;Bei jedem vollen Block
jsr print ; '.' ausgeben
keinuebertrag jsr checkstop ;Stoptaste abfragen
beq endholefile
ldx #1 ;Print nach File
jsr ckout
jsr centrin ;Zeichen in a
jsr checksum ;zur Checksumme addieren
jsr print ;und in File schreiben
jsr clrch ;wieder nach Bildschirm
beq holefile ;ist immer eq nach clrch
endholefile jsr closefile ;und schließen
lda #<endtransmittxt
ldy #>endtransmittxt
jsr strout
jsr centrin ;Checksumme holen
jsr checkchecksum ;Checksumme überprüfen
jsr centrin ;Weitere Files?
beq receiveend
jmp startreceive ;dann wieder zum Start
receiveend rts ;sonst Ende
;-------------------------------------------------------------------------
;Syncronisation zu Begin
syncin lda #$00 ;Eingabe
sta cia2+cia_ddrb ;von Parallelport
lda cia2+cia_prb ;Port löschen
synci1 ldx #5 ;Warten auf 5 Nullbytes
synci2 jsr centrin
bne synci1
dex
bne synci2
synci3 jsr centrin ;Nullbytes überlesen
beq synci3 ;Warten auf Countdown
sta pointer2 ;Zwischenspeichern
dec pointer2
synci4 jsr centrin ;Countdown 987654321
cmp pointer2
bne synci1 ;Fehler im Countdown
dec pointer2
bne synci4
rts
;-------------------------------------------------------------------------
;Zeichen Eingabe von Centronics in den Akku
centrin lda cia2+cia_icr ;Interrupt Control Register lesen
and #cia_flag ;Daten gebracht?
beq centrin ;sonst warten
lda cia2+cia_prb ;Lesen
rts ;ok
;-------------------------------------------------------------------------
;öffnet File oder verläßt das Programm
openfile jsr strlen ;strlen in x
txa ; nach a
ldx #<inputbuffer
ldy #>inputbuffer
jsr setnam ;Filenamen setzen
lda #1 ;Filenummer
ldx #8 ;Geräteadresse
ldy #2 ;Sekundäradresse
jsr setfls ;Fileparameter setzten
jsr open ;und öffnen
bcc openok
jmp errorout ;Fehler und Ende
openok rts
;-------------------------------------------------------------------------
;schließt das File wieder
closefile lda #1
jmp close
;-------------------------------------------------------------------------
;holt Stringlänge des inputbuffer nach x
strlen ldx #-1
strlen1 inx
lda inputbuffer,x
bne strlen1
strlen2 rts
;-------------------------------------------------------------------------
;Gibt die Filelänge aus
showlen lda #<lentext ;Filelängentext ausgeben
ldy #>lentext
jsr strout
ldx pointer1 ;x = lo
lda pointer1+1 ;a = hi
jsr uintout ;Länge ausgeben
lda #13
jsr print ;mit Return abschließen
rts
;-------------------------------------------------------------------------
;Unterroutinen für die Checksumme
startchecksum sta tape_checksum1 ;Checksumme initialisieren
rts
checksum pha ;Akku retten
clc
adc tape_checksum1 ;Checksumme addieren
sta tape_checksum1
pla ;Akku wiederherstellen
rts
checkchecksum cmp tape_checksum1
bne checkerror ;Fehler in der Checksumme?
lda #<checkoktxt ;Chechsum ok
ldy #>checkoktxt
jmp strout ;ok
checkerror lda #<checkerrortxt
ldy #>checkerrortxt
jmp strout ;Fehler
checksend lda tape_checksum1
jsr centrout
rts
;-------------------------------------------------------------------------
textreceive .byte 13,"RECEIVE-CENTRONICS-ROUTINEN",13
.byte "VON H.BEHRENS (C)1991",13,0
wartefiletext .byte "WARTE AUF FILE...",13,0
filenametext .byte "FILENAME:",0
lentext .byte 13,"LAENGE :",0
laeufttext .byte 13,"UEBERTRAGUNG LAEUFT.",0
endtransmittxt .byte 13,"UEBERTRAGUNG BEENDET.",13,0
checkoktxt .byte "CHECKSUMME OK.",13,0
checkerrortxt .byte "FEHLER IN DER CHECKSUMME.",13,0
;*************************************************************************
;Files zum Amiga senden
startsend lda #<textsend ;Begrüßungstext
ldy #>textsend
jsr strout ;ausgeben
lda #<filenametext ;Aufforderung
ldy #>filenametext ; zum Eintippen des
jsr strout ; Filenamen
jsr strin ;Zeile mit Filenamen holen
jsr openfile ;File öffnen
jsr syncout ;Syncronisation
ldx #-1 ;Filenamen senden
sendname inx
lda inputbuffer,x ;Filenamen holen
jsr centrout ;und senden
bne sendname ;bis Null-Byte = Abschluß
jsr loadfile ;File in den Speicher
jsr showlen ;Filelänge anzeigen
jsr sendfile ;File zum Amiga senden
jsr closefile ;und schließen
lda #<endtransmittxt
ldy #>endtransmittxt
jsr strout
jsr nochmal ;weitere Files senden
bne startsend ; dann wieder zum Anfang
; ldx #0 ;am Schluß
; txa ; den PAR:-Buffer des
;sendfillbuffer jsr centrout ; Amiga mit
; dex ; Nullen füllen
; bne sendfillbuffer ;
rts ;Ende
;-------------------------------------------------------------------------
;wenn a=pos sendet er das File, sonst Filelänge in pointer1
loadfile lda #<loadingtxt ;Loading... ausgeben
ldy #>loadingtxt
jsr strout
lda #0 ;Die Filelängen-
sta pointer1 ; zähler
sta pointer1+1 ; löschen
lda strend ;Anfang
sta pointer2 ; im Speicher hinter
lda strend +1 ; das Basic setzen
sta pointer2+1 ; wenn zuwenig Speicher, dann Pech gehabt
ldx #1 ;Eingabe (get)
jsr chkin ; von File
sfl1 jsr getstatus ;Schleifenanfang
cmp #64 ;Fileende?
beq sflend ; dann Schleife verlassen
jsr checkstop ;Stoptaste?
beq sflend ; dann Schleife verlassen
inc pointer1 ;16 Bit Zeichen zählen
bne sfl2 ;übertrag?
inc pointer1+1 ; dann Highbyte inkrementieren
sfl2 jsr get ;Zeichen in a aus File holen
ldy #0
sta (pointer2),y ;Speichern
inc pointer2 ; und Pointer erhöhen
bne sfl3
inc pointer2+1
sfl3 jmp sfl1 ;Schleife wiederholen
sflend jsr clrch ;Kanal löschen
rts
;-------------------------------------------------------------------------
sendfile lda #<laeufttext ;Sendemeldung
ldy #>laeufttext
jsr strout ; ausgeben
lda pointer1
jsr startchecksum ;Checksumme erstellen
jsr centrout ; lo senden
lda pointer1+1
jsr checksum
jsr centrout ; hi senden
lda strend ;Pointer auf Daten setzen
sta pointer2
lda strend +1
sta pointer2+1
sendf1 lda pointer1
ora pointer1+1
beq sendf3 ;Ende von den Daten erreicht
ldy #0
lda (pointer2),y
jsr checksum
jsr centrout
inc pointer2 ;Zeiger auf Daten inkrementieren
bne sendf2
inc pointer2+1
sendf2 sec ;Filelänge dekrementieren
lda pointer1
sbc #1
sta pointer1
bcs sendf1
dec pointer1+1
lda #'.
jsr print
jmp sendf1
sendf3 jsr checksend ;Checksumme senden
rts
;-------------------------------------------------------------------------
;Syncronisation zu Beginn
syncout ldy #$ff ;Parallelport
sty cia2+cia_ddrb ; auf Ausgang schalten
ldx #20 ;erstmal 20 Nullbytes
lda #0
synco2 jsr centrout
dex
bne synco2
ldx #9 ;Countdown 987654321
synco3 txa
jsr centrout
dex
bne synco3
rts
;-------------------------------------------------------------------------
;Zeichen im Akku auf Userport ausgeben (Centronics)
; y wird verändert
centrout sta cia2+cia_prb ;Schreiben
tay ;Akku retten
centrloop1 lda cia2+cia_icr ;Interrupt Control Register lesen
and #cia_flag ;Daten geholt?
beq centrloop1 ;sonst warten
tya ;Akku wiederherstellen
rts ;ok
;-------------------------------------------------------------------------
;Abfrage auf Wiederholung
nochmal lda #<nochmaltxt
ldy #>nochmaltxt
jsr strout ;Abfragetext ausgeben
noch1 jsr get
beq noch1
tax ;Akku retten
cmp #'J
beq noch2
cmp #'N
beq noch3
bne noch1
noch2 ldx #$ff ;Weitere Files senden
.byte $2c ;BIT $xxxx
noch3 ldx #0
jsr print
lda #13
jsr print
txa
jsr centrout
rts
;-------------------------------------------------------------------------
textsend .byte 13,"SEND-CENTRONICS-ROUTINEN",13
.byte "VON H.BEHRENS (C)1991",13,0
loadingtxt .byte "LOADING FILE...",13,0
nochmaltxt .byte "NOCH EIN FILE (J/N)? ",0
.end
|
;=============================================================================
; @(#)xp-midi-echo.asm
; ________.________
; ____ ____ ______/ __ \ ____/
; / ___\ / _ \/ ___/\____ /____ \
; / /_/ > <_> )___ \ / // \
; \___ / \____/____ > /____//______ /
;/_____/ \/ \/
; Copyright (c) 2016 Alessandro Fraschetti (gos95@gommagomma.net).
;
; This file is part of the pic-assembly-midi-xp project:
; https://github.com/pic-assembly-midi-xp
;
; Author.....: Alessandro Fraschetti
; Company....: gos95
; Target.....: Microchip PICmicro MidRange Microcontroller
; Compiler...: Microchip Assembler (MPASM)
; Version....: 1.0 2016/01/05
; Description: Simple MIDI echo
;=============================================================================
; Permission is hereby granted, free of charge, to any person obtaining a copy
; of this software and associated documentation files (the "Software"), to deal
; in the Software without restriction, including without limitation the rights
; to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
; copies of the Software, and to permit persons to whom the Software is
; furnished to do so, subject to the following conditions:
; The above copyright notice and this permission notice shall be included in all
; copies or substantial portions of the Software.
; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
; IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
; FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
; AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
; LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
; OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
; SOFTWARE.
;=============================================================================
PROCESSOR 16f648a
INCLUDE <p16f648a.inc>
;=============================================================================
; CONFIGURATION
;=============================================================================
__CONFIG _CP_OFF & _DATA_CP_OFF & _LVP_OFF & _BOREN_OFF & _MCLRE_ON & _WDT_OFF & _PWRTE_ON & _HS_OSC
;=============================================================================
; CONSTANT DEFINITIONS
;=============================================================================
constant BYTE_RECEIVED = 0x00 ; midi-in byte received flag
constant OVERRUN_ERROR = 0x01 ; midi-in overrun error flag
constant FRAME_ERROR = 0x02 ; midi-in frame error flag
;=============================================================================
; VARIABLE DEFINITIONS
;=============================================================================
XPMIDI_VAR UDATA
midiInSettlingTime RES 1 ; midi-in settling time for start-up
midiInStatus RES 1 ; midi-in Status Register
midiInByte RES 1 ; midi-in received byte Register
;=============================================================================
; RESET VECTOR
;=============================================================================
RESET CODE 0x0000 ; processor reset vector
pagesel MAIN ;
goto MAIN ; go to beginning of program
;=============================================================================
; INIT ROUTINES VECTOR
;=============================================================================
INIT_ROUTINES CODE ; routines vector
; ---------------------------------------------------------------------------
; Init I/O Ports. Set RB1 (RX) and RB2(TX) as Input, the others PIN as Output
; ---------------------------------------------------------------------------
init_ports
errorlevel -302
; init PORTB
movlw 1<<RB2
banksel PORTB
movwf PORTB ; clear output data latches and set RB2=TX
banksel TRISB
movlw 1<<RB2|1<<RB1
movwf TRISB ; configure RB1 and RB2 as inputs
errorlevel +302
return
; ---------------------------------------------------------------------------
; Init USART
; ---------------------------------------------------------------------------
init_usart
errorlevel -302
banksel TXSTA
bcf TXSTA, TX9 ; 8-bit tx
bcf TXSTA, TXEN ; disable tx
bcf TXSTA, SYNC ; asynchronous mode
bcf TXSTA, BRGH ; high bound rate
; movlw d'07' ; 31250 bauds on 4MHz osc. (BRGH=1)
; movlw d'39' ; 31250 bauds on 20MHz osc. (BRGH=1)
movlw d'09' ; 31250 bauds on 20MHz osc. (BRGH=0)
movwf SPBRG
bsf TXSTA, TXEN ; enable tx
banksel RCSTA
bsf RCSTA, SPEN ; enable serial port
bcf RCSTA, RX9 ; 8-bit rx
bsf RCSTA, CREN ; enable continuous rx
banksel midiInSettlingTime
clrf midiInSettlingTime ; provide a settling time for start-up
decfsz midiInSettlingTime, F
goto $-1
banksel RCREG
movf RCREG, W ; flush buffer
movf RCREG, W
movf RCREG, W
errorlevel +302
return
; ---------------------------------------------------------------------------
; TX routines
; ---------------------------------------------------------------------------
send_char_and_wait
banksel TXREG
movwf TXREG ; load tx register with W
; nop
btfss PIR1, TXIF ; wait for end of transmission
goto $-1
return
tx_wait
banksel PIR1
btfss PIR1, TXIF ; wait for end of transmission
goto $-1
return
; ---------------------------------------------------------------------------
; RX routines
; ---------------------------------------------------------------------------
wait_until_receive_char
banksel PIR1
btfss PIR1, RCIF ; wait for data
goto $-1
banksel RCSTA
btfsc RCSTA, OERR ; test for overrun error
goto errOERR
btfsc RCSTA, FERR ; test for frame error
goto errFERR
banksel RCREG
movf RCREG, W ; read received data
movwf midiInByte
return
errOERR
banksel RCSTA
bcf RCSTA, CREN
bsf RCSTA, CREN
banksel midiInStatus
bsf midiInStatus, OVERRUN_ERROR ; set overrun error flag
return
errFERR
banksel RCREG
movf RCREG, W
banksel midiInStatus
bsf midiInStatus, FRAME_ERROR ; set frame error flag
return
; ---------------------------------------------------------------------------
; RX/TX handler routines
; ---------------------------------------------------------------------------
error_handler
banksel midiInStatus
clrf midiInStatus
return
;=============================================================================
; MAIN PROGRAM
;=============================================================================
MAINPROGRAM CODE ; begin program
MAIN
pagesel init_ports
call init_ports
call init_usart
banksel midiInStatus
clrf midiInStatus
mainloop
call wait_until_receive_char ; read usart data
movf midiInStatus, F ; test for usart errors
btfss STATUS, Z
call error_handler
; movf midiInByte, W ; test for system message family
; andlw b'11110000'
; sublw b'11110000'
; btfsc STATUS, Z ; skip system message family
; goto mainloop
movf midiInByte, W ; echo byte
call send_char_and_wait
goto mainloop
END ; end program
|
; void tshr_scroll_up(uchar prows, uchar attr)
SECTION code_clib
SECTION code_arch
PUBLIC _tshr_scroll_up_callee
EXTERN asm_tshr_scroll_up
_tshr_scroll_up_callee:
pop hl
ex (sp),hl
ld e,l
ld l,h
ld d,0
jp asm_tshr_scroll_up
|
_kill: file format elf32-littlearm
Disassembly of section .text:
00000000 <main>:
0: e92d4800 push {fp, lr}
4: e28db004 add fp, sp, #4
8: e24dd010 sub sp, sp, #16
c: e50b0010 str r0, [fp, #-16]
10: e50b1014 str r1, [fp, #-20] ; 0xffffffec
14: e51b3010 ldr r3, [fp, #-16]
18: e3530000 cmp r3, #0
1c: ca000003 bgt 30 <main+0x30>
20: e3a00002 mov r0, #2
24: e59f1058 ldr r1, [pc, #88] ; 84 <main+0x84>
28: eb000260 bl 9b0 <printf>
2c: eb000152 bl 57c <exit>
30: e3a03001 mov r3, #1
34: e50b3008 str r3, [fp, #-8]
38: ea00000c b 70 <main+0x70>
3c: e51b3008 ldr r3, [fp, #-8]
40: e1a03103 lsl r3, r3, #2
44: e51b2014 ldr r2, [fp, #-20] ; 0xffffffec
48: e0823003 add r3, r2, r3
4c: e5933000 ldr r3, [r3]
50: e1a00003 mov r0, r3
54: eb000101 bl 460 <atoi>
58: e1a03000 mov r3, r0
5c: e1a00003 mov r0, r3
60: eb00017b bl 654 <kill>
64: e51b3008 ldr r3, [fp, #-8]
68: e2833001 add r3, r3, #1
6c: e50b3008 str r3, [fp, #-8]
70: e51b2008 ldr r2, [fp, #-8]
74: e51b3010 ldr r3, [fp, #-16]
78: e1520003 cmp r2, r3
7c: baffffee blt 3c <main+0x3c>
80: eb00013d bl 57c <exit>
84: 00001060 .word 0x00001060
00000088 <strcpy>:
88: e52db004 push {fp} ; (str fp, [sp, #-4]!)
8c: e28db000 add fp, sp, #0
90: e24dd014 sub sp, sp, #20
94: e50b0010 str r0, [fp, #-16]
98: e50b1014 str r1, [fp, #-20] ; 0xffffffec
9c: e51b3010 ldr r3, [fp, #-16]
a0: e50b3008 str r3, [fp, #-8]
a4: e1a00000 nop ; (mov r0, r0)
a8: e51b3010 ldr r3, [fp, #-16]
ac: e2832001 add r2, r3, #1
b0: e50b2010 str r2, [fp, #-16]
b4: e51b2014 ldr r2, [fp, #-20] ; 0xffffffec
b8: e2821001 add r1, r2, #1
bc: e50b1014 str r1, [fp, #-20] ; 0xffffffec
c0: e5d22000 ldrb r2, [r2]
c4: e5c32000 strb r2, [r3]
c8: e5d33000 ldrb r3, [r3]
cc: e3530000 cmp r3, #0
d0: 1afffff4 bne a8 <strcpy+0x20>
d4: e51b3008 ldr r3, [fp, #-8]
d8: e1a00003 mov r0, r3
dc: e24bd000 sub sp, fp, #0
e0: e49db004 pop {fp} ; (ldr fp, [sp], #4)
e4: e12fff1e bx lr
000000e8 <strcmp>:
e8: e52db004 push {fp} ; (str fp, [sp, #-4]!)
ec: e28db000 add fp, sp, #0
f0: e24dd00c sub sp, sp, #12
f4: e50b0008 str r0, [fp, #-8]
f8: e50b100c str r1, [fp, #-12]
fc: ea000005 b 118 <strcmp+0x30>
100: e51b3008 ldr r3, [fp, #-8]
104: e2833001 add r3, r3, #1
108: e50b3008 str r3, [fp, #-8]
10c: e51b300c ldr r3, [fp, #-12]
110: e2833001 add r3, r3, #1
114: e50b300c str r3, [fp, #-12]
118: e51b3008 ldr r3, [fp, #-8]
11c: e5d33000 ldrb r3, [r3]
120: e3530000 cmp r3, #0
124: 0a000005 beq 140 <strcmp+0x58>
128: e51b3008 ldr r3, [fp, #-8]
12c: e5d32000 ldrb r2, [r3]
130: e51b300c ldr r3, [fp, #-12]
134: e5d33000 ldrb r3, [r3]
138: e1520003 cmp r2, r3
13c: 0affffef beq 100 <strcmp+0x18>
140: e51b3008 ldr r3, [fp, #-8]
144: e5d33000 ldrb r3, [r3]
148: e1a02003 mov r2, r3
14c: e51b300c ldr r3, [fp, #-12]
150: e5d33000 ldrb r3, [r3]
154: e0633002 rsb r3, r3, r2
158: e1a00003 mov r0, r3
15c: e24bd000 sub sp, fp, #0
160: e49db004 pop {fp} ; (ldr fp, [sp], #4)
164: e12fff1e bx lr
00000168 <strlen>:
168: e52db004 push {fp} ; (str fp, [sp, #-4]!)
16c: e28db000 add fp, sp, #0
170: e24dd014 sub sp, sp, #20
174: e50b0010 str r0, [fp, #-16]
178: e3a03000 mov r3, #0
17c: e50b3008 str r3, [fp, #-8]
180: ea000002 b 190 <strlen+0x28>
184: e51b3008 ldr r3, [fp, #-8]
188: e2833001 add r3, r3, #1
18c: e50b3008 str r3, [fp, #-8]
190: e51b3008 ldr r3, [fp, #-8]
194: e51b2010 ldr r2, [fp, #-16]
198: e0823003 add r3, r2, r3
19c: e5d33000 ldrb r3, [r3]
1a0: e3530000 cmp r3, #0
1a4: 1afffff6 bne 184 <strlen+0x1c>
1a8: e51b3008 ldr r3, [fp, #-8]
1ac: e1a00003 mov r0, r3
1b0: e24bd000 sub sp, fp, #0
1b4: e49db004 pop {fp} ; (ldr fp, [sp], #4)
1b8: e12fff1e bx lr
000001bc <memset>:
1bc: e52db004 push {fp} ; (str fp, [sp, #-4]!)
1c0: e28db000 add fp, sp, #0
1c4: e24dd024 sub sp, sp, #36 ; 0x24
1c8: e50b0018 str r0, [fp, #-24] ; 0xffffffe8
1cc: e50b101c str r1, [fp, #-28] ; 0xffffffe4
1d0: e50b2020 str r2, [fp, #-32] ; 0xffffffe0
1d4: e51b3018 ldr r3, [fp, #-24] ; 0xffffffe8
1d8: e50b3008 str r3, [fp, #-8]
1dc: e51b301c ldr r3, [fp, #-28] ; 0xffffffe4
1e0: e54b300d strb r3, [fp, #-13]
1e4: e55b300d ldrb r3, [fp, #-13]
1e8: e1a02c03 lsl r2, r3, #24
1ec: e55b300d ldrb r3, [fp, #-13]
1f0: e1a03803 lsl r3, r3, #16
1f4: e1822003 orr r2, r2, r3
1f8: e55b300d ldrb r3, [fp, #-13]
1fc: e1a03403 lsl r3, r3, #8
200: e1822003 orr r2, r2, r3
204: e55b300d ldrb r3, [fp, #-13]
208: e1823003 orr r3, r2, r3
20c: e50b3014 str r3, [fp, #-20] ; 0xffffffec
210: ea000008 b 238 <memset+0x7c>
214: e51b3008 ldr r3, [fp, #-8]
218: e55b200d ldrb r2, [fp, #-13]
21c: e5c32000 strb r2, [r3]
220: e51b3020 ldr r3, [fp, #-32] ; 0xffffffe0
224: e2433001 sub r3, r3, #1
228: e50b3020 str r3, [fp, #-32] ; 0xffffffe0
22c: e51b3008 ldr r3, [fp, #-8]
230: e2833001 add r3, r3, #1
234: e50b3008 str r3, [fp, #-8]
238: e51b3020 ldr r3, [fp, #-32] ; 0xffffffe0
23c: e3530000 cmp r3, #0
240: 0a000003 beq 254 <memset+0x98>
244: e51b3008 ldr r3, [fp, #-8]
248: e2033003 and r3, r3, #3
24c: e3530000 cmp r3, #0
250: 1affffef bne 214 <memset+0x58>
254: e51b3008 ldr r3, [fp, #-8]
258: e50b300c str r3, [fp, #-12]
25c: ea000008 b 284 <memset+0xc8>
260: e51b300c ldr r3, [fp, #-12]
264: e51b2014 ldr r2, [fp, #-20] ; 0xffffffec
268: e5832000 str r2, [r3]
26c: e51b3020 ldr r3, [fp, #-32] ; 0xffffffe0
270: e2433004 sub r3, r3, #4
274: e50b3020 str r3, [fp, #-32] ; 0xffffffe0
278: e51b300c ldr r3, [fp, #-12]
27c: e2833004 add r3, r3, #4
280: e50b300c str r3, [fp, #-12]
284: e51b3020 ldr r3, [fp, #-32] ; 0xffffffe0
288: e3530003 cmp r3, #3
28c: 8afffff3 bhi 260 <memset+0xa4>
290: e51b300c ldr r3, [fp, #-12]
294: e50b3008 str r3, [fp, #-8]
298: ea000008 b 2c0 <memset+0x104>
29c: e51b3008 ldr r3, [fp, #-8]
2a0: e55b200d ldrb r2, [fp, #-13]
2a4: e5c32000 strb r2, [r3]
2a8: e51b3020 ldr r3, [fp, #-32] ; 0xffffffe0
2ac: e2433001 sub r3, r3, #1
2b0: e50b3020 str r3, [fp, #-32] ; 0xffffffe0
2b4: e51b3008 ldr r3, [fp, #-8]
2b8: e2833001 add r3, r3, #1
2bc: e50b3008 str r3, [fp, #-8]
2c0: e51b3020 ldr r3, [fp, #-32] ; 0xffffffe0
2c4: e3530000 cmp r3, #0
2c8: 1afffff3 bne 29c <memset+0xe0>
2cc: e51b3018 ldr r3, [fp, #-24] ; 0xffffffe8
2d0: e1a00003 mov r0, r3
2d4: e24bd000 sub sp, fp, #0
2d8: e49db004 pop {fp} ; (ldr fp, [sp], #4)
2dc: e12fff1e bx lr
000002e0 <strchr>:
2e0: e52db004 push {fp} ; (str fp, [sp, #-4]!)
2e4: e28db000 add fp, sp, #0
2e8: e24dd00c sub sp, sp, #12
2ec: e50b0008 str r0, [fp, #-8]
2f0: e1a03001 mov r3, r1
2f4: e54b3009 strb r3, [fp, #-9]
2f8: ea000009 b 324 <strchr+0x44>
2fc: e51b3008 ldr r3, [fp, #-8]
300: e5d33000 ldrb r3, [r3]
304: e55b2009 ldrb r2, [fp, #-9]
308: e1520003 cmp r2, r3
30c: 1a000001 bne 318 <strchr+0x38>
310: e51b3008 ldr r3, [fp, #-8]
314: ea000007 b 338 <strchr+0x58>
318: e51b3008 ldr r3, [fp, #-8]
31c: e2833001 add r3, r3, #1
320: e50b3008 str r3, [fp, #-8]
324: e51b3008 ldr r3, [fp, #-8]
328: e5d33000 ldrb r3, [r3]
32c: e3530000 cmp r3, #0
330: 1afffff1 bne 2fc <strchr+0x1c>
334: e3a03000 mov r3, #0
338: e1a00003 mov r0, r3
33c: e24bd000 sub sp, fp, #0
340: e49db004 pop {fp} ; (ldr fp, [sp], #4)
344: e12fff1e bx lr
00000348 <gets>:
348: e92d4800 push {fp, lr}
34c: e28db004 add fp, sp, #4
350: e24dd018 sub sp, sp, #24
354: e50b0018 str r0, [fp, #-24] ; 0xffffffe8
358: e50b101c str r1, [fp, #-28] ; 0xffffffe4
35c: e3a03000 mov r3, #0
360: e50b3008 str r3, [fp, #-8]
364: ea000017 b 3c8 <gets+0x80>
368: e24b300d sub r3, fp, #13
36c: e3a00000 mov r0, #0
370: e1a01003 mov r1, r3
374: e3a02001 mov r2, #1
378: eb00009a bl 5e8 <read>
37c: e50b000c str r0, [fp, #-12]
380: e51b300c ldr r3, [fp, #-12]
384: e3530000 cmp r3, #0
388: ca000000 bgt 390 <gets+0x48>
38c: ea000012 b 3dc <gets+0x94>
390: e51b3008 ldr r3, [fp, #-8]
394: e2832001 add r2, r3, #1
398: e50b2008 str r2, [fp, #-8]
39c: e1a02003 mov r2, r3
3a0: e51b3018 ldr r3, [fp, #-24] ; 0xffffffe8
3a4: e0833002 add r3, r3, r2
3a8: e55b200d ldrb r2, [fp, #-13]
3ac: e5c32000 strb r2, [r3]
3b0: e55b300d ldrb r3, [fp, #-13]
3b4: e353000a cmp r3, #10
3b8: 0a000007 beq 3dc <gets+0x94>
3bc: e55b300d ldrb r3, [fp, #-13]
3c0: e353000d cmp r3, #13
3c4: 0a000004 beq 3dc <gets+0x94>
3c8: e51b3008 ldr r3, [fp, #-8]
3cc: e2832001 add r2, r3, #1
3d0: e51b301c ldr r3, [fp, #-28] ; 0xffffffe4
3d4: e1520003 cmp r2, r3
3d8: baffffe2 blt 368 <gets+0x20>
3dc: e51b3008 ldr r3, [fp, #-8]
3e0: e51b2018 ldr r2, [fp, #-24] ; 0xffffffe8
3e4: e0823003 add r3, r2, r3
3e8: e3a02000 mov r2, #0
3ec: e5c32000 strb r2, [r3]
3f0: e51b3018 ldr r3, [fp, #-24] ; 0xffffffe8
3f4: e1a00003 mov r0, r3
3f8: e24bd004 sub sp, fp, #4
3fc: e8bd8800 pop {fp, pc}
00000400 <stat>:
400: e92d4800 push {fp, lr}
404: e28db004 add fp, sp, #4
408: e24dd010 sub sp, sp, #16
40c: e50b0010 str r0, [fp, #-16]
410: e50b1014 str r1, [fp, #-20] ; 0xffffffec
414: e51b0010 ldr r0, [fp, #-16]
418: e3a01000 mov r1, #0
41c: eb00009e bl 69c <open>
420: e50b0008 str r0, [fp, #-8]
424: e51b3008 ldr r3, [fp, #-8]
428: e3530000 cmp r3, #0
42c: aa000001 bge 438 <stat+0x38>
430: e3e03000 mvn r3, #0
434: ea000006 b 454 <stat+0x54>
438: e51b0008 ldr r0, [fp, #-8]
43c: e51b1014 ldr r1, [fp, #-20] ; 0xffffffec
440: eb0000b0 bl 708 <fstat>
444: e50b000c str r0, [fp, #-12]
448: e51b0008 ldr r0, [fp, #-8]
44c: eb000077 bl 630 <close>
450: e51b300c ldr r3, [fp, #-12]
454: e1a00003 mov r0, r3
458: e24bd004 sub sp, fp, #4
45c: e8bd8800 pop {fp, pc}
00000460 <atoi>:
460: e52db004 push {fp} ; (str fp, [sp, #-4]!)
464: e28db000 add fp, sp, #0
468: e24dd014 sub sp, sp, #20
46c: e50b0010 str r0, [fp, #-16]
470: e3a03000 mov r3, #0
474: e50b3008 str r3, [fp, #-8]
478: ea00000c b 4b0 <atoi+0x50>
47c: e51b2008 ldr r2, [fp, #-8]
480: e1a03002 mov r3, r2
484: e1a03103 lsl r3, r3, #2
488: e0833002 add r3, r3, r2
48c: e1a03083 lsl r3, r3, #1
490: e1a01003 mov r1, r3
494: e51b3010 ldr r3, [fp, #-16]
498: e2832001 add r2, r3, #1
49c: e50b2010 str r2, [fp, #-16]
4a0: e5d33000 ldrb r3, [r3]
4a4: e0813003 add r3, r1, r3
4a8: e2433030 sub r3, r3, #48 ; 0x30
4ac: e50b3008 str r3, [fp, #-8]
4b0: e51b3010 ldr r3, [fp, #-16]
4b4: e5d33000 ldrb r3, [r3]
4b8: e353002f cmp r3, #47 ; 0x2f
4bc: 9a000003 bls 4d0 <atoi+0x70>
4c0: e51b3010 ldr r3, [fp, #-16]
4c4: e5d33000 ldrb r3, [r3]
4c8: e3530039 cmp r3, #57 ; 0x39
4cc: 9affffea bls 47c <atoi+0x1c>
4d0: e51b3008 ldr r3, [fp, #-8]
4d4: e1a00003 mov r0, r3
4d8: e24bd000 sub sp, fp, #0
4dc: e49db004 pop {fp} ; (ldr fp, [sp], #4)
4e0: e12fff1e bx lr
000004e4 <memmove>:
4e4: e52db004 push {fp} ; (str fp, [sp, #-4]!)
4e8: e28db000 add fp, sp, #0
4ec: e24dd01c sub sp, sp, #28
4f0: e50b0010 str r0, [fp, #-16]
4f4: e50b1014 str r1, [fp, #-20] ; 0xffffffec
4f8: e50b2018 str r2, [fp, #-24] ; 0xffffffe8
4fc: e51b3010 ldr r3, [fp, #-16]
500: e50b3008 str r3, [fp, #-8]
504: e51b3014 ldr r3, [fp, #-20] ; 0xffffffec
508: e50b300c str r3, [fp, #-12]
50c: ea000007 b 530 <memmove+0x4c>
510: e51b3008 ldr r3, [fp, #-8]
514: e2832001 add r2, r3, #1
518: e50b2008 str r2, [fp, #-8]
51c: e51b200c ldr r2, [fp, #-12]
520: e2821001 add r1, r2, #1
524: e50b100c str r1, [fp, #-12]
528: e5d22000 ldrb r2, [r2]
52c: e5c32000 strb r2, [r3]
530: e51b3018 ldr r3, [fp, #-24] ; 0xffffffe8
534: e2432001 sub r2, r3, #1
538: e50b2018 str r2, [fp, #-24] ; 0xffffffe8
53c: e3530000 cmp r3, #0
540: cafffff2 bgt 510 <memmove+0x2c>
544: e51b3010 ldr r3, [fp, #-16]
548: e1a00003 mov r0, r3
54c: e24bd000 sub sp, fp, #0
550: e49db004 pop {fp} ; (ldr fp, [sp], #4)
554: e12fff1e bx lr
00000558 <fork>:
558: e52d4004 push {r4} ; (str r4, [sp, #-4]!)
55c: e1a04003 mov r4, r3
560: e1a03002 mov r3, r2
564: e1a02001 mov r2, r1
568: e1a01000 mov r1, r0
56c: e3a00001 mov r0, #1
570: ef000000 svc 0x00000000
574: e49d4004 pop {r4} ; (ldr r4, [sp], #4)
578: e12fff1e bx lr
0000057c <exit>:
57c: e52d4004 push {r4} ; (str r4, [sp, #-4]!)
580: e1a04003 mov r4, r3
584: e1a03002 mov r3, r2
588: e1a02001 mov r2, r1
58c: e1a01000 mov r1, r0
590: e3a00002 mov r0, #2
594: ef000000 svc 0x00000000
598: e49d4004 pop {r4} ; (ldr r4, [sp], #4)
59c: e12fff1e bx lr
000005a0 <wait>:
5a0: e52d4004 push {r4} ; (str r4, [sp, #-4]!)
5a4: e1a04003 mov r4, r3
5a8: e1a03002 mov r3, r2
5ac: e1a02001 mov r2, r1
5b0: e1a01000 mov r1, r0
5b4: e3a00003 mov r0, #3
5b8: ef000000 svc 0x00000000
5bc: e49d4004 pop {r4} ; (ldr r4, [sp], #4)
5c0: e12fff1e bx lr
000005c4 <pipe>:
5c4: e52d4004 push {r4} ; (str r4, [sp, #-4]!)
5c8: e1a04003 mov r4, r3
5cc: e1a03002 mov r3, r2
5d0: e1a02001 mov r2, r1
5d4: e1a01000 mov r1, r0
5d8: e3a00004 mov r0, #4
5dc: ef000000 svc 0x00000000
5e0: e49d4004 pop {r4} ; (ldr r4, [sp], #4)
5e4: e12fff1e bx lr
000005e8 <read>:
5e8: e52d4004 push {r4} ; (str r4, [sp, #-4]!)
5ec: e1a04003 mov r4, r3
5f0: e1a03002 mov r3, r2
5f4: e1a02001 mov r2, r1
5f8: e1a01000 mov r1, r0
5fc: e3a00005 mov r0, #5
600: ef000000 svc 0x00000000
604: e49d4004 pop {r4} ; (ldr r4, [sp], #4)
608: e12fff1e bx lr
0000060c <write>:
60c: e52d4004 push {r4} ; (str r4, [sp, #-4]!)
610: e1a04003 mov r4, r3
614: e1a03002 mov r3, r2
618: e1a02001 mov r2, r1
61c: e1a01000 mov r1, r0
620: e3a00010 mov r0, #16
624: ef000000 svc 0x00000000
628: e49d4004 pop {r4} ; (ldr r4, [sp], #4)
62c: e12fff1e bx lr
00000630 <close>:
630: e52d4004 push {r4} ; (str r4, [sp, #-4]!)
634: e1a04003 mov r4, r3
638: e1a03002 mov r3, r2
63c: e1a02001 mov r2, r1
640: e1a01000 mov r1, r0
644: e3a00015 mov r0, #21
648: ef000000 svc 0x00000000
64c: e49d4004 pop {r4} ; (ldr r4, [sp], #4)
650: e12fff1e bx lr
00000654 <kill>:
654: e52d4004 push {r4} ; (str r4, [sp, #-4]!)
658: e1a04003 mov r4, r3
65c: e1a03002 mov r3, r2
660: e1a02001 mov r2, r1
664: e1a01000 mov r1, r0
668: e3a00006 mov r0, #6
66c: ef000000 svc 0x00000000
670: e49d4004 pop {r4} ; (ldr r4, [sp], #4)
674: e12fff1e bx lr
00000678 <exec>:
678: e52d4004 push {r4} ; (str r4, [sp, #-4]!)
67c: e1a04003 mov r4, r3
680: e1a03002 mov r3, r2
684: e1a02001 mov r2, r1
688: e1a01000 mov r1, r0
68c: e3a00007 mov r0, #7
690: ef000000 svc 0x00000000
694: e49d4004 pop {r4} ; (ldr r4, [sp], #4)
698: e12fff1e bx lr
0000069c <open>:
69c: e52d4004 push {r4} ; (str r4, [sp, #-4]!)
6a0: e1a04003 mov r4, r3
6a4: e1a03002 mov r3, r2
6a8: e1a02001 mov r2, r1
6ac: e1a01000 mov r1, r0
6b0: e3a0000f mov r0, #15
6b4: ef000000 svc 0x00000000
6b8: e49d4004 pop {r4} ; (ldr r4, [sp], #4)
6bc: e12fff1e bx lr
000006c0 <mknod>:
6c0: e52d4004 push {r4} ; (str r4, [sp, #-4]!)
6c4: e1a04003 mov r4, r3
6c8: e1a03002 mov r3, r2
6cc: e1a02001 mov r2, r1
6d0: e1a01000 mov r1, r0
6d4: e3a00011 mov r0, #17
6d8: ef000000 svc 0x00000000
6dc: e49d4004 pop {r4} ; (ldr r4, [sp], #4)
6e0: e12fff1e bx lr
000006e4 <unlink>:
6e4: e52d4004 push {r4} ; (str r4, [sp, #-4]!)
6e8: e1a04003 mov r4, r3
6ec: e1a03002 mov r3, r2
6f0: e1a02001 mov r2, r1
6f4: e1a01000 mov r1, r0
6f8: e3a00012 mov r0, #18
6fc: ef000000 svc 0x00000000
700: e49d4004 pop {r4} ; (ldr r4, [sp], #4)
704: e12fff1e bx lr
00000708 <fstat>:
708: e52d4004 push {r4} ; (str r4, [sp, #-4]!)
70c: e1a04003 mov r4, r3
710: e1a03002 mov r3, r2
714: e1a02001 mov r2, r1
718: e1a01000 mov r1, r0
71c: e3a00008 mov r0, #8
720: ef000000 svc 0x00000000
724: e49d4004 pop {r4} ; (ldr r4, [sp], #4)
728: e12fff1e bx lr
0000072c <link>:
72c: e52d4004 push {r4} ; (str r4, [sp, #-4]!)
730: e1a04003 mov r4, r3
734: e1a03002 mov r3, r2
738: e1a02001 mov r2, r1
73c: e1a01000 mov r1, r0
740: e3a00013 mov r0, #19
744: ef000000 svc 0x00000000
748: e49d4004 pop {r4} ; (ldr r4, [sp], #4)
74c: e12fff1e bx lr
00000750 <mkdir>:
750: e52d4004 push {r4} ; (str r4, [sp, #-4]!)
754: e1a04003 mov r4, r3
758: e1a03002 mov r3, r2
75c: e1a02001 mov r2, r1
760: e1a01000 mov r1, r0
764: e3a00014 mov r0, #20
768: ef000000 svc 0x00000000
76c: e49d4004 pop {r4} ; (ldr r4, [sp], #4)
770: e12fff1e bx lr
00000774 <chdir>:
774: e52d4004 push {r4} ; (str r4, [sp, #-4]!)
778: e1a04003 mov r4, r3
77c: e1a03002 mov r3, r2
780: e1a02001 mov r2, r1
784: e1a01000 mov r1, r0
788: e3a00009 mov r0, #9
78c: ef000000 svc 0x00000000
790: e49d4004 pop {r4} ; (ldr r4, [sp], #4)
794: e12fff1e bx lr
00000798 <dup>:
798: e52d4004 push {r4} ; (str r4, [sp, #-4]!)
79c: e1a04003 mov r4, r3
7a0: e1a03002 mov r3, r2
7a4: e1a02001 mov r2, r1
7a8: e1a01000 mov r1, r0
7ac: e3a0000a mov r0, #10
7b0: ef000000 svc 0x00000000
7b4: e49d4004 pop {r4} ; (ldr r4, [sp], #4)
7b8: e12fff1e bx lr
000007bc <getpid>:
7bc: e52d4004 push {r4} ; (str r4, [sp, #-4]!)
7c0: e1a04003 mov r4, r3
7c4: e1a03002 mov r3, r2
7c8: e1a02001 mov r2, r1
7cc: e1a01000 mov r1, r0
7d0: e3a0000b mov r0, #11
7d4: ef000000 svc 0x00000000
7d8: e49d4004 pop {r4} ; (ldr r4, [sp], #4)
7dc: e12fff1e bx lr
000007e0 <sbrk>:
7e0: e52d4004 push {r4} ; (str r4, [sp, #-4]!)
7e4: e1a04003 mov r4, r3
7e8: e1a03002 mov r3, r2
7ec: e1a02001 mov r2, r1
7f0: e1a01000 mov r1, r0
7f4: e3a0000c mov r0, #12
7f8: ef000000 svc 0x00000000
7fc: e49d4004 pop {r4} ; (ldr r4, [sp], #4)
800: e12fff1e bx lr
00000804 <sleep>:
804: e52d4004 push {r4} ; (str r4, [sp, #-4]!)
808: e1a04003 mov r4, r3
80c: e1a03002 mov r3, r2
810: e1a02001 mov r2, r1
814: e1a01000 mov r1, r0
818: e3a0000d mov r0, #13
81c: ef000000 svc 0x00000000
820: e49d4004 pop {r4} ; (ldr r4, [sp], #4)
824: e12fff1e bx lr
00000828 <uptime>:
828: e52d4004 push {r4} ; (str r4, [sp, #-4]!)
82c: e1a04003 mov r4, r3
830: e1a03002 mov r3, r2
834: e1a02001 mov r2, r1
838: e1a01000 mov r1, r0
83c: e3a0000e mov r0, #14
840: ef000000 svc 0x00000000
844: e49d4004 pop {r4} ; (ldr r4, [sp], #4)
848: e12fff1e bx lr
0000084c <putc>:
84c: e92d4800 push {fp, lr}
850: e28db004 add fp, sp, #4
854: e24dd008 sub sp, sp, #8
858: e50b0008 str r0, [fp, #-8]
85c: e1a03001 mov r3, r1
860: e54b3009 strb r3, [fp, #-9]
864: e24b3009 sub r3, fp, #9
868: e51b0008 ldr r0, [fp, #-8]
86c: e1a01003 mov r1, r3
870: e3a02001 mov r2, #1
874: ebffff64 bl 60c <write>
878: e24bd004 sub sp, fp, #4
87c: e8bd8800 pop {fp, pc}
00000880 <printint>:
880: e92d4810 push {r4, fp, lr}
884: e28db008 add fp, sp, #8
888: e24dd034 sub sp, sp, #52 ; 0x34
88c: e50b0030 str r0, [fp, #-48] ; 0xffffffd0
890: e50b1034 str r1, [fp, #-52] ; 0xffffffcc
894: e50b2038 str r2, [fp, #-56] ; 0xffffffc8
898: e50b303c str r3, [fp, #-60] ; 0xffffffc4
89c: e3a03000 mov r3, #0
8a0: e50b3014 str r3, [fp, #-20] ; 0xffffffec
8a4: e51b303c ldr r3, [fp, #-60] ; 0xffffffc4
8a8: e3530000 cmp r3, #0
8ac: 0a000008 beq 8d4 <printint+0x54>
8b0: e51b3034 ldr r3, [fp, #-52] ; 0xffffffcc
8b4: e3530000 cmp r3, #0
8b8: aa000005 bge 8d4 <printint+0x54>
8bc: e3a03001 mov r3, #1
8c0: e50b3014 str r3, [fp, #-20] ; 0xffffffec
8c4: e51b3034 ldr r3, [fp, #-52] ; 0xffffffcc
8c8: e2633000 rsb r3, r3, #0
8cc: e50b3018 str r3, [fp, #-24] ; 0xffffffe8
8d0: ea000001 b 8dc <printint+0x5c>
8d4: e51b3034 ldr r3, [fp, #-52] ; 0xffffffcc
8d8: e50b3018 str r3, [fp, #-24] ; 0xffffffe8
8dc: e3a03000 mov r3, #0
8e0: e50b3010 str r3, [fp, #-16]
8e4: e51b4010 ldr r4, [fp, #-16]
8e8: e2843001 add r3, r4, #1
8ec: e50b3010 str r3, [fp, #-16]
8f0: e51b3038 ldr r3, [fp, #-56] ; 0xffffffc8
8f4: e51b2018 ldr r2, [fp, #-24] ; 0xffffffe8
8f8: e1a00002 mov r0, r2
8fc: e1a01003 mov r1, r3
900: eb0001cd bl 103c <__aeabi_uidivmod>
904: e1a03001 mov r3, r1
908: e1a02003 mov r2, r3
90c: e59f3098 ldr r3, [pc, #152] ; 9ac <printint+0x12c>
910: e7d32002 ldrb r2, [r3, r2]
914: e24b300c sub r3, fp, #12
918: e0833004 add r3, r3, r4
91c: e543201c strb r2, [r3, #-28] ; 0xffffffe4
920: e51b3038 ldr r3, [fp, #-56] ; 0xffffffc8
924: e51b0018 ldr r0, [fp, #-24] ; 0xffffffe8
928: e1a01003 mov r1, r3
92c: eb000185 bl f48 <__aeabi_uidiv>
930: e1a03000 mov r3, r0
934: e50b3018 str r3, [fp, #-24] ; 0xffffffe8
938: e51b3018 ldr r3, [fp, #-24] ; 0xffffffe8
93c: e3530000 cmp r3, #0
940: 1affffe7 bne 8e4 <printint+0x64>
944: e51b3014 ldr r3, [fp, #-20] ; 0xffffffec
948: e3530000 cmp r3, #0
94c: 0a000006 beq 96c <printint+0xec>
950: e51b3010 ldr r3, [fp, #-16]
954: e2832001 add r2, r3, #1
958: e50b2010 str r2, [fp, #-16]
95c: e24b200c sub r2, fp, #12
960: e0823003 add r3, r2, r3
964: e3a0202d mov r2, #45 ; 0x2d
968: e543201c strb r2, [r3, #-28] ; 0xffffffe4
96c: ea000006 b 98c <printint+0x10c>
970: e24b2028 sub r2, fp, #40 ; 0x28
974: e51b3010 ldr r3, [fp, #-16]
978: e0823003 add r3, r2, r3
97c: e5d33000 ldrb r3, [r3]
980: e51b0030 ldr r0, [fp, #-48] ; 0xffffffd0
984: e1a01003 mov r1, r3
988: ebffffaf bl 84c <putc>
98c: e51b3010 ldr r3, [fp, #-16]
990: e2433001 sub r3, r3, #1
994: e50b3010 str r3, [fp, #-16]
998: e51b3010 ldr r3, [fp, #-16]
99c: e3530000 cmp r3, #0
9a0: aafffff2 bge 970 <printint+0xf0>
9a4: e24bd008 sub sp, fp, #8
9a8: e8bd8810 pop {r4, fp, pc}
9ac: 0000107c .word 0x0000107c
000009b0 <printf>:
9b0: e92d000e push {r1, r2, r3}
9b4: e92d4800 push {fp, lr}
9b8: e28db004 add fp, sp, #4
9bc: e24dd024 sub sp, sp, #36 ; 0x24
9c0: e50b0024 str r0, [fp, #-36] ; 0xffffffdc
9c4: e3a03000 mov r3, #0
9c8: e50b3014 str r3, [fp, #-20] ; 0xffffffec
9cc: e28b3008 add r3, fp, #8
9d0: e50b3018 str r3, [fp, #-24] ; 0xffffffe8
9d4: e3a03000 mov r3, #0
9d8: e50b3010 str r3, [fp, #-16]
9dc: ea000074 b bb4 <printf+0x204>
9e0: e59b2004 ldr r2, [fp, #4]
9e4: e51b3010 ldr r3, [fp, #-16]
9e8: e0823003 add r3, r2, r3
9ec: e5d33000 ldrb r3, [r3]
9f0: e50b301c str r3, [fp, #-28] ; 0xffffffe4
9f4: e51b3014 ldr r3, [fp, #-20] ; 0xffffffec
9f8: e3530000 cmp r3, #0
9fc: 1a00000b bne a30 <printf+0x80>
a00: e51b301c ldr r3, [fp, #-28] ; 0xffffffe4
a04: e3530025 cmp r3, #37 ; 0x25
a08: 1a000002 bne a18 <printf+0x68>
a0c: e3a03025 mov r3, #37 ; 0x25
a10: e50b3014 str r3, [fp, #-20] ; 0xffffffec
a14: ea000063 b ba8 <printf+0x1f8>
a18: e51b301c ldr r3, [fp, #-28] ; 0xffffffe4
a1c: e6ef3073 uxtb r3, r3
a20: e51b0024 ldr r0, [fp, #-36] ; 0xffffffdc
a24: e1a01003 mov r1, r3
a28: ebffff87 bl 84c <putc>
a2c: ea00005d b ba8 <printf+0x1f8>
a30: e51b3014 ldr r3, [fp, #-20] ; 0xffffffec
a34: e3530025 cmp r3, #37 ; 0x25
a38: 1a00005a bne ba8 <printf+0x1f8>
a3c: e51b301c ldr r3, [fp, #-28] ; 0xffffffe4
a40: e3530064 cmp r3, #100 ; 0x64
a44: 1a00000a bne a74 <printf+0xc4>
a48: e51b3018 ldr r3, [fp, #-24] ; 0xffffffe8
a4c: e5933000 ldr r3, [r3]
a50: e51b0024 ldr r0, [fp, #-36] ; 0xffffffdc
a54: e1a01003 mov r1, r3
a58: e3a0200a mov r2, #10
a5c: e3a03001 mov r3, #1
a60: ebffff86 bl 880 <printint>
a64: e51b3018 ldr r3, [fp, #-24] ; 0xffffffe8
a68: e2833004 add r3, r3, #4
a6c: e50b3018 str r3, [fp, #-24] ; 0xffffffe8
a70: ea00004a b ba0 <printf+0x1f0>
a74: e51b301c ldr r3, [fp, #-28] ; 0xffffffe4
a78: e3530078 cmp r3, #120 ; 0x78
a7c: 0a000002 beq a8c <printf+0xdc>
a80: e51b301c ldr r3, [fp, #-28] ; 0xffffffe4
a84: e3530070 cmp r3, #112 ; 0x70
a88: 1a00000a bne ab8 <printf+0x108>
a8c: e51b3018 ldr r3, [fp, #-24] ; 0xffffffe8
a90: e5933000 ldr r3, [r3]
a94: e51b0024 ldr r0, [fp, #-36] ; 0xffffffdc
a98: e1a01003 mov r1, r3
a9c: e3a02010 mov r2, #16
aa0: e3a03000 mov r3, #0
aa4: ebffff75 bl 880 <printint>
aa8: e51b3018 ldr r3, [fp, #-24] ; 0xffffffe8
aac: e2833004 add r3, r3, #4
ab0: e50b3018 str r3, [fp, #-24] ; 0xffffffe8
ab4: ea000039 b ba0 <printf+0x1f0>
ab8: e51b301c ldr r3, [fp, #-28] ; 0xffffffe4
abc: e3530073 cmp r3, #115 ; 0x73
ac0: 1a000018 bne b28 <printf+0x178>
ac4: e51b3018 ldr r3, [fp, #-24] ; 0xffffffe8
ac8: e5933000 ldr r3, [r3]
acc: e50b300c str r3, [fp, #-12]
ad0: e51b3018 ldr r3, [fp, #-24] ; 0xffffffe8
ad4: e2833004 add r3, r3, #4
ad8: e50b3018 str r3, [fp, #-24] ; 0xffffffe8
adc: e51b300c ldr r3, [fp, #-12]
ae0: e3530000 cmp r3, #0
ae4: 1a000001 bne af0 <printf+0x140>
ae8: e59f30ec ldr r3, [pc, #236] ; bdc <printf+0x22c>
aec: e50b300c str r3, [fp, #-12]
af0: ea000007 b b14 <printf+0x164>
af4: e51b300c ldr r3, [fp, #-12]
af8: e5d33000 ldrb r3, [r3]
afc: e51b0024 ldr r0, [fp, #-36] ; 0xffffffdc
b00: e1a01003 mov r1, r3
b04: ebffff50 bl 84c <putc>
b08: e51b300c ldr r3, [fp, #-12]
b0c: e2833001 add r3, r3, #1
b10: e50b300c str r3, [fp, #-12]
b14: e51b300c ldr r3, [fp, #-12]
b18: e5d33000 ldrb r3, [r3]
b1c: e3530000 cmp r3, #0
b20: 1afffff3 bne af4 <printf+0x144>
b24: ea00001d b ba0 <printf+0x1f0>
b28: e51b301c ldr r3, [fp, #-28] ; 0xffffffe4
b2c: e3530063 cmp r3, #99 ; 0x63
b30: 1a000009 bne b5c <printf+0x1ac>
b34: e51b3018 ldr r3, [fp, #-24] ; 0xffffffe8
b38: e5933000 ldr r3, [r3]
b3c: e6ef3073 uxtb r3, r3
b40: e51b0024 ldr r0, [fp, #-36] ; 0xffffffdc
b44: e1a01003 mov r1, r3
b48: ebffff3f bl 84c <putc>
b4c: e51b3018 ldr r3, [fp, #-24] ; 0xffffffe8
b50: e2833004 add r3, r3, #4
b54: e50b3018 str r3, [fp, #-24] ; 0xffffffe8
b58: ea000010 b ba0 <printf+0x1f0>
b5c: e51b301c ldr r3, [fp, #-28] ; 0xffffffe4
b60: e3530025 cmp r3, #37 ; 0x25
b64: 1a000005 bne b80 <printf+0x1d0>
b68: e51b301c ldr r3, [fp, #-28] ; 0xffffffe4
b6c: e6ef3073 uxtb r3, r3
b70: e51b0024 ldr r0, [fp, #-36] ; 0xffffffdc
b74: e1a01003 mov r1, r3
b78: ebffff33 bl 84c <putc>
b7c: ea000007 b ba0 <printf+0x1f0>
b80: e51b0024 ldr r0, [fp, #-36] ; 0xffffffdc
b84: e3a01025 mov r1, #37 ; 0x25
b88: ebffff2f bl 84c <putc>
b8c: e51b301c ldr r3, [fp, #-28] ; 0xffffffe4
b90: e6ef3073 uxtb r3, r3
b94: e51b0024 ldr r0, [fp, #-36] ; 0xffffffdc
b98: e1a01003 mov r1, r3
b9c: ebffff2a bl 84c <putc>
ba0: e3a03000 mov r3, #0
ba4: e50b3014 str r3, [fp, #-20] ; 0xffffffec
ba8: e51b3010 ldr r3, [fp, #-16]
bac: e2833001 add r3, r3, #1
bb0: e50b3010 str r3, [fp, #-16]
bb4: e59b2004 ldr r2, [fp, #4]
bb8: e51b3010 ldr r3, [fp, #-16]
bbc: e0823003 add r3, r2, r3
bc0: e5d33000 ldrb r3, [r3]
bc4: e3530000 cmp r3, #0
bc8: 1affff84 bne 9e0 <printf+0x30>
bcc: e24bd004 sub sp, fp, #4
bd0: e8bd4800 pop {fp, lr}
bd4: e28dd00c add sp, sp, #12
bd8: e12fff1e bx lr
bdc: 00001074 .word 0x00001074
00000be0 <free>:
be0: e52db004 push {fp} ; (str fp, [sp, #-4]!)
be4: e28db000 add fp, sp, #0
be8: e24dd014 sub sp, sp, #20
bec: e50b0010 str r0, [fp, #-16]
bf0: e51b3010 ldr r3, [fp, #-16]
bf4: e2433008 sub r3, r3, #8
bf8: e50b300c str r3, [fp, #-12]
bfc: e59f3150 ldr r3, [pc, #336] ; d54 <free+0x174>
c00: e5933000 ldr r3, [r3]
c04: e50b3008 str r3, [fp, #-8]
c08: ea000010 b c50 <free+0x70>
c0c: e51b3008 ldr r3, [fp, #-8]
c10: e5932000 ldr r2, [r3]
c14: e51b3008 ldr r3, [fp, #-8]
c18: e1520003 cmp r2, r3
c1c: 8a000008 bhi c44 <free+0x64>
c20: e51b200c ldr r2, [fp, #-12]
c24: e51b3008 ldr r3, [fp, #-8]
c28: e1520003 cmp r2, r3
c2c: 8a000010 bhi c74 <free+0x94>
c30: e51b3008 ldr r3, [fp, #-8]
c34: e5932000 ldr r2, [r3]
c38: e51b300c ldr r3, [fp, #-12]
c3c: e1520003 cmp r2, r3
c40: 8a00000b bhi c74 <free+0x94>
c44: e51b3008 ldr r3, [fp, #-8]
c48: e5933000 ldr r3, [r3]
c4c: e50b3008 str r3, [fp, #-8]
c50: e51b200c ldr r2, [fp, #-12]
c54: e51b3008 ldr r3, [fp, #-8]
c58: e1520003 cmp r2, r3
c5c: 9affffea bls c0c <free+0x2c>
c60: e51b3008 ldr r3, [fp, #-8]
c64: e5932000 ldr r2, [r3]
c68: e51b300c ldr r3, [fp, #-12]
c6c: e1520003 cmp r2, r3
c70: 9affffe5 bls c0c <free+0x2c>
c74: e51b300c ldr r3, [fp, #-12]
c78: e5933004 ldr r3, [r3, #4]
c7c: e1a03183 lsl r3, r3, #3
c80: e51b200c ldr r2, [fp, #-12]
c84: e0822003 add r2, r2, r3
c88: e51b3008 ldr r3, [fp, #-8]
c8c: e5933000 ldr r3, [r3]
c90: e1520003 cmp r2, r3
c94: 1a00000d bne cd0 <free+0xf0>
c98: e51b300c ldr r3, [fp, #-12]
c9c: e5932004 ldr r2, [r3, #4]
ca0: e51b3008 ldr r3, [fp, #-8]
ca4: e5933000 ldr r3, [r3]
ca8: e5933004 ldr r3, [r3, #4]
cac: e0822003 add r2, r2, r3
cb0: e51b300c ldr r3, [fp, #-12]
cb4: e5832004 str r2, [r3, #4]
cb8: e51b3008 ldr r3, [fp, #-8]
cbc: e5933000 ldr r3, [r3]
cc0: e5932000 ldr r2, [r3]
cc4: e51b300c ldr r3, [fp, #-12]
cc8: e5832000 str r2, [r3]
ccc: ea000003 b ce0 <free+0x100>
cd0: e51b3008 ldr r3, [fp, #-8]
cd4: e5932000 ldr r2, [r3]
cd8: e51b300c ldr r3, [fp, #-12]
cdc: e5832000 str r2, [r3]
ce0: e51b3008 ldr r3, [fp, #-8]
ce4: e5933004 ldr r3, [r3, #4]
ce8: e1a03183 lsl r3, r3, #3
cec: e51b2008 ldr r2, [fp, #-8]
cf0: e0822003 add r2, r2, r3
cf4: e51b300c ldr r3, [fp, #-12]
cf8: e1520003 cmp r2, r3
cfc: 1a00000b bne d30 <free+0x150>
d00: e51b3008 ldr r3, [fp, #-8]
d04: e5932004 ldr r2, [r3, #4]
d08: e51b300c ldr r3, [fp, #-12]
d0c: e5933004 ldr r3, [r3, #4]
d10: e0822003 add r2, r2, r3
d14: e51b3008 ldr r3, [fp, #-8]
d18: e5832004 str r2, [r3, #4]
d1c: e51b300c ldr r3, [fp, #-12]
d20: e5932000 ldr r2, [r3]
d24: e51b3008 ldr r3, [fp, #-8]
d28: e5832000 str r2, [r3]
d2c: ea000002 b d3c <free+0x15c>
d30: e51b3008 ldr r3, [fp, #-8]
d34: e51b200c ldr r2, [fp, #-12]
d38: e5832000 str r2, [r3]
d3c: e59f2010 ldr r2, [pc, #16] ; d54 <free+0x174>
d40: e51b3008 ldr r3, [fp, #-8]
d44: e5823000 str r3, [r2]
d48: e24bd000 sub sp, fp, #0
d4c: e49db004 pop {fp} ; (ldr fp, [sp], #4)
d50: e12fff1e bx lr
d54: 00001098 .word 0x00001098
00000d58 <morecore>:
d58: e92d4800 push {fp, lr}
d5c: e28db004 add fp, sp, #4
d60: e24dd010 sub sp, sp, #16
d64: e50b0010 str r0, [fp, #-16]
d68: e51b3010 ldr r3, [fp, #-16]
d6c: e3530a01 cmp r3, #4096 ; 0x1000
d70: 2a000001 bcs d7c <morecore+0x24>
d74: e3a03a01 mov r3, #4096 ; 0x1000
d78: e50b3010 str r3, [fp, #-16]
d7c: e51b3010 ldr r3, [fp, #-16]
d80: e1a03183 lsl r3, r3, #3
d84: e1a00003 mov r0, r3
d88: ebfffe94 bl 7e0 <sbrk>
d8c: e50b0008 str r0, [fp, #-8]
d90: e51b3008 ldr r3, [fp, #-8]
d94: e3730001 cmn r3, #1
d98: 1a000001 bne da4 <morecore+0x4c>
d9c: e3a03000 mov r3, #0
da0: ea00000a b dd0 <morecore+0x78>
da4: e51b3008 ldr r3, [fp, #-8]
da8: e50b300c str r3, [fp, #-12]
dac: e51b300c ldr r3, [fp, #-12]
db0: e51b2010 ldr r2, [fp, #-16]
db4: e5832004 str r2, [r3, #4]
db8: e51b300c ldr r3, [fp, #-12]
dbc: e2833008 add r3, r3, #8
dc0: e1a00003 mov r0, r3
dc4: ebffff85 bl be0 <free>
dc8: e59f300c ldr r3, [pc, #12] ; ddc <morecore+0x84>
dcc: e5933000 ldr r3, [r3]
dd0: e1a00003 mov r0, r3
dd4: e24bd004 sub sp, fp, #4
dd8: e8bd8800 pop {fp, pc}
ddc: 00001098 .word 0x00001098
00000de0 <malloc>:
de0: e92d4800 push {fp, lr}
de4: e28db004 add fp, sp, #4
de8: e24dd018 sub sp, sp, #24
dec: e50b0018 str r0, [fp, #-24] ; 0xffffffe8
df0: e51b3018 ldr r3, [fp, #-24] ; 0xffffffe8
df4: e2833007 add r3, r3, #7
df8: e1a031a3 lsr r3, r3, #3
dfc: e2833001 add r3, r3, #1
e00: e50b3010 str r3, [fp, #-16]
e04: e59f3134 ldr r3, [pc, #308] ; f40 <malloc+0x160>
e08: e5933000 ldr r3, [r3]
e0c: e50b300c str r3, [fp, #-12]
e10: e51b300c ldr r3, [fp, #-12]
e14: e3530000 cmp r3, #0
e18: 1a00000b bne e4c <malloc+0x6c>
e1c: e59f3120 ldr r3, [pc, #288] ; f44 <malloc+0x164>
e20: e50b300c str r3, [fp, #-12]
e24: e59f2114 ldr r2, [pc, #276] ; f40 <malloc+0x160>
e28: e51b300c ldr r3, [fp, #-12]
e2c: e5823000 str r3, [r2]
e30: e59f3108 ldr r3, [pc, #264] ; f40 <malloc+0x160>
e34: e5933000 ldr r3, [r3]
e38: e59f2104 ldr r2, [pc, #260] ; f44 <malloc+0x164>
e3c: e5823000 str r3, [r2]
e40: e59f30fc ldr r3, [pc, #252] ; f44 <malloc+0x164>
e44: e3a02000 mov r2, #0
e48: e5832004 str r2, [r3, #4]
e4c: e51b300c ldr r3, [fp, #-12]
e50: e5933000 ldr r3, [r3]
e54: e50b3008 str r3, [fp, #-8]
e58: e51b3008 ldr r3, [fp, #-8]
e5c: e5932004 ldr r2, [r3, #4]
e60: e51b3010 ldr r3, [fp, #-16]
e64: e1520003 cmp r2, r3
e68: 3a00001e bcc ee8 <malloc+0x108>
e6c: e51b3008 ldr r3, [fp, #-8]
e70: e5932004 ldr r2, [r3, #4]
e74: e51b3010 ldr r3, [fp, #-16]
e78: e1520003 cmp r2, r3
e7c: 1a000004 bne e94 <malloc+0xb4>
e80: e51b3008 ldr r3, [fp, #-8]
e84: e5932000 ldr r2, [r3]
e88: e51b300c ldr r3, [fp, #-12]
e8c: e5832000 str r2, [r3]
e90: ea00000e b ed0 <malloc+0xf0>
e94: e51b3008 ldr r3, [fp, #-8]
e98: e5932004 ldr r2, [r3, #4]
e9c: e51b3010 ldr r3, [fp, #-16]
ea0: e0632002 rsb r2, r3, r2
ea4: e51b3008 ldr r3, [fp, #-8]
ea8: e5832004 str r2, [r3, #4]
eac: e51b3008 ldr r3, [fp, #-8]
eb0: e5933004 ldr r3, [r3, #4]
eb4: e1a03183 lsl r3, r3, #3
eb8: e51b2008 ldr r2, [fp, #-8]
ebc: e0823003 add r3, r2, r3
ec0: e50b3008 str r3, [fp, #-8]
ec4: e51b3008 ldr r3, [fp, #-8]
ec8: e51b2010 ldr r2, [fp, #-16]
ecc: e5832004 str r2, [r3, #4]
ed0: e59f2068 ldr r2, [pc, #104] ; f40 <malloc+0x160>
ed4: e51b300c ldr r3, [fp, #-12]
ed8: e5823000 str r3, [r2]
edc: e51b3008 ldr r3, [fp, #-8]
ee0: e2833008 add r3, r3, #8
ee4: ea000012 b f34 <malloc+0x154>
ee8: e59f3050 ldr r3, [pc, #80] ; f40 <malloc+0x160>
eec: e5933000 ldr r3, [r3]
ef0: e51b2008 ldr r2, [fp, #-8]
ef4: e1520003 cmp r2, r3
ef8: 1a000007 bne f1c <malloc+0x13c>
efc: e51b0010 ldr r0, [fp, #-16]
f00: ebffff94 bl d58 <morecore>
f04: e50b0008 str r0, [fp, #-8]
f08: e51b3008 ldr r3, [fp, #-8]
f0c: e3530000 cmp r3, #0
f10: 1a000001 bne f1c <malloc+0x13c>
f14: e3a03000 mov r3, #0
f18: ea000005 b f34 <malloc+0x154>
f1c: e51b3008 ldr r3, [fp, #-8]
f20: e50b300c str r3, [fp, #-12]
f24: e51b3008 ldr r3, [fp, #-8]
f28: e5933000 ldr r3, [r3]
f2c: e50b3008 str r3, [fp, #-8]
f30: eaffffc8 b e58 <malloc+0x78>
f34: e1a00003 mov r0, r3
f38: e24bd004 sub sp, fp, #4
f3c: e8bd8800 pop {fp, pc}
f40: 00001098 .word 0x00001098
f44: 00001090 .word 0x00001090
00000f48 <__aeabi_uidiv>:
f48: e2512001 subs r2, r1, #1
f4c: 012fff1e bxeq lr
f50: 3a000036 bcc 1030 <__aeabi_uidiv+0xe8>
f54: e1500001 cmp r0, r1
f58: 9a000022 bls fe8 <__aeabi_uidiv+0xa0>
f5c: e1110002 tst r1, r2
f60: 0a000023 beq ff4 <__aeabi_uidiv+0xac>
f64: e311020e tst r1, #-536870912 ; 0xe0000000
f68: 01a01181 lsleq r1, r1, #3
f6c: 03a03008 moveq r3, #8
f70: 13a03001 movne r3, #1
f74: e3510201 cmp r1, #268435456 ; 0x10000000
f78: 31510000 cmpcc r1, r0
f7c: 31a01201 lslcc r1, r1, #4
f80: 31a03203 lslcc r3, r3, #4
f84: 3afffffa bcc f74 <__aeabi_uidiv+0x2c>
f88: e3510102 cmp r1, #-2147483648 ; 0x80000000
f8c: 31510000 cmpcc r1, r0
f90: 31a01081 lslcc r1, r1, #1
f94: 31a03083 lslcc r3, r3, #1
f98: 3afffffa bcc f88 <__aeabi_uidiv+0x40>
f9c: e3a02000 mov r2, #0
fa0: e1500001 cmp r0, r1
fa4: 20400001 subcs r0, r0, r1
fa8: 21822003 orrcs r2, r2, r3
fac: e15000a1 cmp r0, r1, lsr #1
fb0: 204000a1 subcs r0, r0, r1, lsr #1
fb4: 218220a3 orrcs r2, r2, r3, lsr #1
fb8: e1500121 cmp r0, r1, lsr #2
fbc: 20400121 subcs r0, r0, r1, lsr #2
fc0: 21822123 orrcs r2, r2, r3, lsr #2
fc4: e15001a1 cmp r0, r1, lsr #3
fc8: 204001a1 subcs r0, r0, r1, lsr #3
fcc: 218221a3 orrcs r2, r2, r3, lsr #3
fd0: e3500000 cmp r0, #0
fd4: 11b03223 lsrsne r3, r3, #4
fd8: 11a01221 lsrne r1, r1, #4
fdc: 1affffef bne fa0 <__aeabi_uidiv+0x58>
fe0: e1a00002 mov r0, r2
fe4: e12fff1e bx lr
fe8: 03a00001 moveq r0, #1
fec: 13a00000 movne r0, #0
ff0: e12fff1e bx lr
ff4: e3510801 cmp r1, #65536 ; 0x10000
ff8: 21a01821 lsrcs r1, r1, #16
ffc: 23a02010 movcs r2, #16
1000: 33a02000 movcc r2, #0
1004: e3510c01 cmp r1, #256 ; 0x100
1008: 21a01421 lsrcs r1, r1, #8
100c: 22822008 addcs r2, r2, #8
1010: e3510010 cmp r1, #16
1014: 21a01221 lsrcs r1, r1, #4
1018: 22822004 addcs r2, r2, #4
101c: e3510004 cmp r1, #4
1020: 82822003 addhi r2, r2, #3
1024: 908220a1 addls r2, r2, r1, lsr #1
1028: e1a00230 lsr r0, r0, r2
102c: e12fff1e bx lr
1030: e3500000 cmp r0, #0
1034: 13e00000 mvnne r0, #0
1038: ea000007 b 105c <__aeabi_idiv0>
0000103c <__aeabi_uidivmod>:
103c: e3510000 cmp r1, #0
1040: 0afffffa beq 1030 <__aeabi_uidiv+0xe8>
1044: e92d4003 push {r0, r1, lr}
1048: ebffffbe bl f48 <__aeabi_uidiv>
104c: e8bd4006 pop {r1, r2, lr}
1050: e0030092 mul r3, r2, r0
1054: e0411003 sub r1, r1, r3
1058: e12fff1e bx lr
0000105c <__aeabi_idiv0>:
105c: e12fff1e bx lr
|
; A097803: a(n) = 3*(2*n^2 + 1).
; 3,9,27,57,99,153,219,297,387,489,603,729,867,1017,1179,1353,1539,1737,1947,2169,2403,2649,2907,3177,3459,3753,4059,4377,4707,5049,5403,5769,6147,6537,6939,7353,7779,8217,8667,9129,9603,10089,10587,11097,11619,12153,12699,13257,13827,14409,15003,15609,16227,16857,17499,18153,18819,19497,20187,20889,21603,22329,23067,23817,24579,25353,26139,26937,27747,28569,29403,30249,31107,31977,32859,33753,34659,35577,36507,37449,38403,39369,40347,41337,42339,43353,44379,45417,46467,47529,48603,49689,50787
pow $0,2
mul $0,6
add $0,3
|
#include "LHC19c2b_TMVAClassification_BDT_6_8_noPCts.class.h"
double ReadBDT_LHC19c2b_6_8_noPCts::GetMvaValue__( const std::vector<double>& inputValues ) const
{
double myMVA = 0;
double norm = 0;
for (unsigned int itree=0; itree<fForest.size(); itree++){
BDTNode *current = fForest[itree];
while (current->GetNodeType() == 0) { //intermediate node
if (current->GoesRight(inputValues)) current=(BDTNode*)current->GetRight();
else current=(BDTNode*)current->GetLeft();
}
myMVA += fBoostWeights[itree] * current->GetNodeType();
norm += fBoostWeights[itree];
}
return myMVA /= norm;
};
void ReadBDT_LHC19c2b_6_8_noPCts::Initialize()
{
// itree = 0
fBoostWeights.push_back(0.381936849189776);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.693403,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.19737,-99) ,
4, 0.999524, 0, 0, 0.654656,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.559656,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.281605,-99) ,
8, -1.92395, 1, 0, 0.438735,-99) ,
6, -951.286, 0, 0, 0.545785,-99) ,
NN(
0,
0,
-1, 2.31975, 1, -1, 0.209134,-99) ,
7, 1.57141, 1, 0, 0.499805,-99) );
// itree = 1
fBoostWeights.push_back(0.335947);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.671274,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.266662,-99) ,
6, -1.57141, 0, 0, 0.617701,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.525866,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.272805,-99) ,
8, -1.54163, 1, 0, 0.417051,-99) ,
6, -951.286, 0, 0, 0.514404,-99) ,
NN(
0,
0,
-1, 1.00138, 1, -1, 0.149369,-99) ,
4, 0.999524, 0, 0, 0.484308,-99) );
// itree = 2
fBoostWeights.push_back(0.269717);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.63014,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.313481,-99) ,
6, -1.5716, 0, 0, 0.593317,-99) ,
NN(
0,
0,
-1, -1.61207, 0, -1, 0.410007,-99) ,
6, -951.286, 0, 0, 0.500472,-99) ,
NN(
0,
0,
-1, 2.29253, 1, -1, 0.18512,-99) ,
7, 1.85718, 1, 0, 0.47135,-99) );
// itree = 3
fBoostWeights.push_back(0.229683);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.580903,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.42473,-99) ,
4, 0.999977, 0, 0, 0.536621,-99) ,
NN(
0,
0,
-1, 0.998617, 0, -1, 0.240309,-99) ,
4, 0.999524, 0, 0, 0.5171,-99) ,
NN(
0,
0,
-1, 2.02044, 1, -1, 0.287362,-99) ,
7, 1.28578, 1, 0, 0.4761,-99) );
// itree = 4
fBoostWeights.push_back(0.193541);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.582033,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.449709,-99) ,
6, -951.286, 0, 0, 0.513291,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.199092,-99) ,
7, 2.14285, 1, 0, 0.496474,-99) ,
NN(
0,
0,
-1, 0.998164, 0, -1, 0.196841,-99) ,
4, 0.999524, 0, 0, 0.473252,-99) );
// itree = 5
fBoostWeights.push_back(0.18897);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.599384,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.45742,-99) ,
4, 0.999955, 0, 0, 0.562447,-99) ,
NN(
0,
0,
-1, -0.99982, 0, -1, 0.425848,-99) ,
9, -0.0122127, 1, 0, 0.496833,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.143227,-99) ,
4, 0.999048, 0, 0, 0.479238,-99) );
// itree = 6
fBoostWeights.push_back(0.155449);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.538473,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.275395,-99) ,
7, -1.77551, 0, 0, 0.52241,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.229857,-99) ,
7, 2.14284, 1, 0, 0.507584,-99) ,
NN(
0,
0,
-1, 0.998164, 0, -1, 0.21956,-99) ,
4, 0.999524, 0, 0, 0.48645,-99) );
// itree = 7
fBoostWeights.push_back(0.143299);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.531044,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.276105,-99) ,
7, -1.85692, 0, 0, 0.517283,-99) ,
NN(
0,
0,
-1, 0.31815, 1, -1, 0.381393,-99) ,
4, 0.999955, 0, 0, 0.488196,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.163686,-99) ,
4, 0.999048, 0, 0, 0.472812,-99) );
// itree = 8
fBoostWeights.push_back(0.164896);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.562129,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.367212,-99) ,
7, 0.506995, 1, 0, 0.543204,-99) ,
NN(
0,
0,
-1, -1.28552, 0, -1, 0.427031,-99) ,
9, -0.412447, 1, 0, 0.47554,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.122219,-99) ,
4, 0.998572, 0, 0, 0.463548,-99) );
// itree = 9
fBoostWeights.push_back(0.0800427);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.50487,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.249147,-99) ,
7, -2.02024, 0, 0, 0.494568,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.226125,-99) ,
4, 0.999048, 0, 0, 0.483406,-99) ,
NN(
0,
0,
-1, 2.51025, 1, -1, 0.213337,-99) ,
7, 2.14288, 1, 0, 0.468529,-99) );
// itree = 10
fBoostWeights.push_back(0.0691381);
fForest.push_back(
NN(
0,
0,
-1, 0.999048, 0, -1, 0.465486,-99) );
// itree = 11
fBoostWeights.push_back(0.0971495);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.511417,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.334224,-99) ,
7, -1.61209, 0, 0, 0.497802,-99) ,
NN(
0,
0,
-1, 2.4557, 1, -1, 0.311342,-99) ,
7, 1.8571, 1, 0, 0.483135,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.188596,-99) ,
4, 0.999048, 0, 0, 0.470142,-99) );
// itree = 12
fBoostWeights.push_back(0.0748637);
fForest.push_back(
NN(
0,
0,
-1, 0.999048, 0, -1, 0.462638,-99) );
// itree = 13
fBoostWeights.push_back(0.0879317);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.511271,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.402671,-99) ,
4, 0.999932, 0, 0, 0.49241,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.210765,-99) ,
7, 2.42856, 1, 0, 0.483967,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.16438,-99) ,
4, 0.998572, 0, 0, 0.473631,-99) );
// itree = 14
fBoostWeights.push_back(0.0616083);
fForest.push_back(
NN(
0,
0,
-1, 0.999048, 0, -1, 0.469235,-99) );
// itree = 15
fBoostWeights.push_back(0.062868);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.503485,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.276097,-99) ,
7, -2.02023, 0, 0, 0.494825,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.217475,-99) ,
4, 0.998572, 0, 0, 0.487086,-99) ,
NN(
0,
0,
-1, 2.51021, 1, -1, 0.249264,-99) ,
7, 2.14288, 1, 0, 0.474788,-99) );
// itree = 16
fBoostWeights.push_back(0.0679777);
fForest.push_back(
NN(
0,
0,
-1, 0.998572, 0, -1, 0.466063,-99) );
// itree = 17
fBoostWeights.push_back(0.0705483);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.506757,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.284122,-99) ,
7, -2.07483, 0, 0, 0.498626,-99) ,
NN(
0,
0,
-1, -951.286, 0, -1, 0.344059,-99) ,
7, 1.8571, 1, 0, 0.48694,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.23954,-99) ,
4, 0.999048, 0, 0, 0.476302,-99) );
// itree = 18
fBoostWeights.push_back(0.055286);
fForest.push_back(
NN(
0,
0,
-1, 0.998572, 0, -1, 0.472385,-99) );
// itree = 19
fBoostWeights.push_back(0.0661774);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.506051,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.384269,-99) ,
4, 0.999864, 0, 0, 0.493035,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.239957,-99) ,
7, 2.42858, 1, 0, 0.48589,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.196008,-99) ,
4, 0.998572, 0, 0, 0.477146,-99) );
// itree = 20
fBoostWeights.push_back(0.0595592);
fForest.push_back(
NN(
0,
0,
-1, 0.998572, 0, -1, 0.470256,-99) );
// itree = 21
fBoostWeights.push_back(0.0827701);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.513973,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.426775,-99) ,
8, -0.845409, 1, 0, 0.494782,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.24434,-99) ,
7, 2.42858, 1, 0, 0.487867,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.19733,-99) ,
4, 0.998572, 0, 0, 0.479277,-99) );
// itree = 22
fBoostWeights.push_back(0.140256);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.565071,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.45317,-99) ,
4, 0.999997, 0, 0, 0.498017,-99) ,
NN(
0,
0,
-1, -0.392842, 1, -1, 0.395404,-99) ,
4, 0.999932, 0, 0, 0.480493,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.201185,-99) ,
4, 0.998572, 0, 0, 0.472312,-99) );
// itree = 23
fBoostWeights.push_back(0.0516268);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.503014,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.328071,-99) ,
4, 0.999048, 0, 0, 0.496247,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.315181,-99) ,
7, -2.02041, 0, 0, 0.489377,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.290796,-99) ,
7, 2.14285, 1, 0, 0.479508,-99) );
// itree = 24
fBoostWeights.push_back(0.0491279);
fForest.push_back(
NN(
0,
0,
-1, 0.998572, 0, -1, 0.475456,-99) );
// itree = 25
fBoostWeights.push_back(0.107633);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.55642,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.391111,-99) ,
7, 0.402825, 1, 0, 0.540822,-99) ,
NN(
0,
0,
-1, -1.2857, 0, -1, 0.461,-99) ,
9, -0.562581, 1, 0, 0.491798,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.245413,-99) ,
4, 0.998572, 0, 0, 0.484681,-99) );
// itree = 26
fBoostWeights.push_back(0.14034);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.572331,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.333411,-99) ,
6, -1.28563, 0, 0, 0.530506,-99) ,
NN(
0,
0,
-1, -1.57125, 0, -1, 0.458728,-99) ,
6, -951.286, 0, 0, 0.493719,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.247844,-99) ,
4, 0.998572, 0, 0, 0.486834,-99) );
// itree = 27
fBoostWeights.push_back(0.0845713);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.521035,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.412625,-99) ,
4, 0.999909, 0, 0, 0.506702,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.273629,-99) ,
7, -2.14266, 0, 0, 0.500286,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.282191,-99) ,
4, 0.999048, 0, 0, 0.491962,-99) );
// itree = 28
fBoostWeights.push_back(0.0781902);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.509044,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.325818,-99) ,
3, 9.25993, 1, 0, 0.501987,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.604994,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.196106,-99) ,
9, -1.70024, 1, 0, 0.380478,-99) ,
7, -1.44899, 0, 0, 0.491084,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.262212,-99) ,
7, 2.42856, 1, 0, 0.484624,-99) );
// itree = 29
fBoostWeights.push_back(0.0606789);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 2.34693, 1, -1, 0.491713,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.576326,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.142508,-99) ,
8, -2.68861, 1, 0, 0.365334,-99) ,
7, -1.57141, 0, 0, 0.482476,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.29435,-99) ,
4, 0.999048, 0, 0, 0.475207,-99) );
// itree = 30
fBoostWeights.push_back(0.063417);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.502376,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.343852,-99) ,
4, 0.999048, 0, 0, 0.49625,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.588122,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.173322,-99) ,
8, -3.07236, 1, 0, 0.380968,-99) ,
7, -1.44881, 0, 0, 0.486007,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.269041,-99) ,
7, 2.42858, 1, 0, 0.480003,-99) );
// itree = 31
fBoostWeights.push_back(0.0498777);
fForest.push_back(
NN(
0,
0,
-1, 9.06322, 1, -1, 0.475082,-99) );
// itree = 32
fBoostWeights.push_back(0.0657842);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.504188,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.339569,-99) ,
3, 9.33163, 1, 0, 0.497987,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.608835,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.20721,-99) ,
9, -1.67007, 1, 0, 0.394764,-99) ,
7, -1.4488, 0, 0, 0.488909,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.269842,-99) ,
7, 2.42858, 1, 0, 0.483008,-99) );
// itree = 33
fBoostWeights.push_back(0.0494838);
fForest.push_back(
NN(
0,
0,
-1, 2.42856, 1, -1, 0.475278,-99) );
// itree = 34
fBoostWeights.push_back(0.0757674);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.507537,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.423721,-99) ,
7, 1.2586, 1, 0, 0.492643,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.579262,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.147797,-99) ,
8, -2.69021, 1, 0, 0.378613,-99) ,
7, -1.57122, 0, 0, 0.484661,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.282755,-99) ,
4, 0.998572, 0, 0, 0.479179,-99) );
// itree = 35
fBoostWeights.push_back(0.0497865);
fForest.push_back(
NN(
0,
0,
-1, 0.998572, 0, -1, 0.475127,-99) );
// itree = 36
fBoostWeights.push_back(0.0454167);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.503834,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.410051,-99) ,
4, 0.999864, 0, 0, 0.493667,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.319126,-99) ,
7, -2.14284, 0, 0, 0.48907,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.290244,-99) ,
4, 0.998572, 0, 0, 0.483786,-99) );
// itree = 37
fBoostWeights.push_back(0.0386634);
fForest.push_back(
NN(
0,
0,
-1, 2.42856, 1, -1, 0.480678,-99) );
// itree = 38
fBoostWeights.push_back(0.0369102);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.501272,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.404829,-99) ,
7, 1.77555, 1, 0, 0.493244,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.33251,-99) ,
7, -2.14266, 0, 0, 0.488972,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.292958,-99) ,
4, 0.998572, 0, 0, 0.483763,-99) );
// itree = 39
fBoostWeights.push_back(0.0662656);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.512452,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.421796,-99) ,
7, -1.44877, 0, 0, 0.504743,-99) ,
NN(
0,
0,
-1, -1.44903, 0, -1, 0.450117,-99) ,
0, 0.499995, 1, 0, 0.48643,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.306583,-99) ,
7, 2.42844, 1, 0, 0.481662,-99) );
// itree = 40
fBoostWeights.push_back(0.0942625);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.530894,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.454845,-99) ,
4, 0.999994, 0, 0, 0.49671,-99) ,
NN(
0,
0,
-1, 0.259915, 1, -1, 0.431115,-99) ,
4, 0.999932, 0, 0, 0.485516,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.29245,-99) ,
4, 0.998572, 0, 0, 0.480482,-99) );
// itree = 41
fBoostWeights.push_back(0.074682);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.512516,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.430827,-99) ,
7, 1.0001, 1, 0, 0.496269,-99) ,
NN(
0,
0,
-1, -0.999853, 0, -1, 0.439412,-99) ,
8, -1.01921, 1, 0, 0.482404,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.289215,-99) ,
4, 0.998572, 0, 0, 0.477508,-99) );
// itree = 42
fBoostWeights.push_back(0.0621755);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 1.97962, 1, -1, 0.492083,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.567373,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.189331,-99) ,
8, -2.65458, 1, 0, 0.406283,-99) ,
7, -1.28554, 0, 0, 0.482811,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.324484,-99) ,
3, 9.27898, 1, 0, 0.477002,-99) );
// itree = 43
fBoostWeights.push_back(0.0713003);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.506821,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.410013,-99) ,
7, 1.97959, 1, 0, 0.500325,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.606115,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.258831,-99) ,
8, -3.64317, 1, 0, 0.414658,-99) ,
7, -1.2857, 0, 0, 0.490957,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.335269,-99) ,
3, 9.32353, 1, 0, 0.485379,-99) );
// itree = 44
fBoostWeights.push_back(0.0736995);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.505929,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.448532,-99) ,
4, 0.999955, 0, 0, 0.493683,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.587896,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.262528,-99) ,
9, -1.66072, 1, 0, 0.417087,-99) ,
7, -1.28555, 0, 0, 0.48526,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.342364,-99) ,
4, 0.999048, 0, 0, 0.480066,-99) );
// itree = 45
fBoostWeights.push_back(0.0545519);
fForest.push_back(
NN(
0,
0,
-1, 9.33163, 1, -1, 0.472751,-99) );
// itree = 46
fBoostWeights.push_back(0.0422829);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 2.34689, 1, -1, 0.49398,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.547934,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.170986,-99) ,
8, -2.26655, 1, 0, 0.395266,-99) ,
7, -1.57142, 0, 0, 0.487327,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.351389,-99) ,
3, 9.33163, 1, 0, 0.482581,-99) );
// itree = 47
fBoostWeights.push_back(0.0958564);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.541461,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.263183,-99) ,
6, -1.85701, 0, 0, 0.517154,-99) ,
NN(
0,
0,
-1, -1.57142, 0, -1, 0.470172,-99) ,
6, -951.286, 0, 0, 0.493258,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.344156,-99) ,
3, 9.34278, 1, 0, 0.488124,-99) );
// itree = 48
fBoostWeights.push_back(0.0596065);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.505311,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.375585,-99) ,
3, 9.37272, 1, 0, 0.500873,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.339498,-99) ,
7, 2.38779, 1, 0, 0.495932,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.588629,-99) ,
NN(
0,
0,
-1, -1.77521, 0, -1, 0.275194,-99) ,
8, -3.72151, 1, 0, 0.419702,-99) ,
7, -1.28544, 0, 0, 0.487818,-99) );
// itree = 49
fBoostWeights.push_back(0.0520859);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.999864, 0, -1, 0.49229,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.578906,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.283269,-99) ,
8, -3.43051, 1, 0, 0.429266,-99) ,
7, -1.2857, 0, 0, 0.48549,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.358186,-99) ,
4, 0.998572, 0, 0, 0.48217,-99) );
// itree = 50
fBoostWeights.push_back(0.0524693);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.507351,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.438172,-99) ,
4, 0.999864, 0, 0, 0.499977,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.56195,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.205827,-99) ,
8, -2.52925, 1, 0, 0.410937,-99) ,
7, -1.57126, 0, 0, 0.49399,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.354761,-99) ,
4, 0.998572, 0, 0, 0.4904,-99) );
// itree = 51
fBoostWeights.push_back(0.0619613);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.555976,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.488292,-99) ,
3, 0.552065, 1, 0, 0.493774,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.367311,-99) ,
3, 9.27109, 1, 0, 0.489157,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.537386,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.232484,-99) ,
8, -2.60816, 1, 0, 0.417528,-99) ,
7, -1.28557, 0, 0, 0.481641,-99) );
// itree = 52
fBoostWeights.push_back(0.0359583);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.5013,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.417869,-99) ,
7, 2.34693, 1, 0, 0.498574,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.54852,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.215889,-99) ,
8, -2.65458, 1, 0, 0.403307,-99) ,
7, -1.57141, 0, 0, 0.492229,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.370802,-99) ,
3, 9.12028, 1, 0, 0.487799,-99) );
// itree = 53
fBoostWeights.push_back(0.0448563);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.58314,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.492464,-99) ,
8, 2.28748, 0, 0, 0.496736,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.379193,-99) ,
3, 9.35068, 1, 0, 0.492675,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.534364,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.244339,-99) ,
8, -2.57412, 1, 0, 0.410619,-99) ,
7, -1.57124, 0, 0, 0.487255,-99) );
// itree = 54
fBoostWeights.push_back(0.0537007);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.510889,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.463694,-99) ,
0, 0.5019, 1, 0, 0.501847,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.373202,-99) ,
4, 0.999048, 0, 0, 0.497264,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.513307,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.209967,-99) ,
9, -0.919421, 1, 0, 0.384876,-99) ,
7, -1.57125, 0, 0, 0.490049,-99) );
// itree = 55
fBoostWeights.push_back(0.0498539);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.571386,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.493682,-99) ,
8, 2.36881, 0, 0, 0.497342,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.390439,-99) ,
4, 0.999048, 0, 0, 0.493462,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.547738,-99) ,
NN(
0,
0,
-1, -1.69369, 0, -1, 0.303359,-99) ,
8, -3.64317, 1, 0, 0.418658,-99) ,
7, -1.28552, 0, 0, 0.485618,-99) );
// itree = 56
fBoostWeights.push_back(0.219379);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.666832,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.494801,-99) ,
7, -1.28545, 0, 0, 0.647163,-99) ,
NN(
0,
0,
-1, 0.00258727, 0, -1, 0.418815,-99) ,
5, 0.00452773, 0, 0, 0.496153,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.240313,-99) ,
5, 0.0237713, 1, 0, 0.489535,-99) );
// itree = 57
fBoostWeights.push_back(0.0631122);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.524991,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.486961,-99) ,
9, 1.10255, 1, 0, 0.515282,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.402252,-99) ,
3, 9.33743, 1, 0, 0.511449,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.555312,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.258389,-99) ,
9, -0.947708, 1, 0, 0.433176,-99) ,
7, -1.57125, 0, 0, 0.506346,-99) );
// itree = 58
fBoostWeights.push_back(0.0608774);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.517192,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.462914,-99) ,
9, -1.91489, 0, 0, 0.513277,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.515905,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.353376,-99) ,
6, -951.286, 0, 0, 0.436475,-99) ,
7, 1.91155, 1, 0, 0.507949,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.555232,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.244852,-99) ,
8, -2.65458, 1, 0, 0.427222,-99) ,
7, -1.57142, 0, 0, 0.502653,-99) );
// itree = 59
fBoostWeights.push_back(0.0497087);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.537731,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.431501,-99) ,
2, 0.242132, 1, 0, 0.524328,-99) ,
NN(
0,
0,
-1, -1.57142, 0, -1, 0.485995,-99) ,
2, 0.0325218, 0, 0, 0.495902,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.397616,-99) ,
2, -0.212026, 0, 0, 0.491434,-99) );
// itree = 60
fBoostWeights.push_back(0.0527506);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.514992,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.472596,-99) ,
0, 0.5019, 1, 0, 0.50688,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.402542,-99) ,
7, 2.34695, 1, 0, 0.503622,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.546817,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.298741,-99) ,
9, -1.35824, 1, 0, 0.430779,-99) ,
7, -1.57125, 0, 0, 0.498861,-99) );
// itree = 61
fBoostWeights.push_back(0.0354411);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.525326,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.49511,-99) ,
2, 0.0304458, 0, 0, 0.503222,-99) ,
NN(
0,
0,
-1, 0.499042, 1, -1, 0.436878,-99) ,
7, -1.57121, 0, 0, 0.498885,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.397862,-99) ,
2, -0.214276, 0, 0, 0.494436,-99) );
// itree = 62
fBoostWeights.push_back(0.0377299);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 2.36881, 0, 1, 0.50438,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.419988,-99) ,
2, -0.21455, 0, 0, 0.500564,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.551585,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.311125,-99) ,
8, -3.22883, 1, 0, 0.439977,-99) ,
7, -1.28553, 0, 0, 0.494334,-99) );
// itree = 63
fBoostWeights.push_back(0.032926);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.618599,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.493455,-99) ,
7, 0.429017, 0, 0, 0.558641,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.500285,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.436722,-99) ,
8, -0.553255, 1, 0, 0.492197,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.380525,-99) ,
7, 2.14287, 1, 0, 0.487544,-99) ,
8, 1.40603, 0, 0, 0.492365,-99) );
// itree = 64
fBoostWeights.push_back(0.0459373);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.503913,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.457241,-99) ,
4, 0.999909, 0, 0, 0.497729,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.55579,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.336858,-99) ,
8, -3.72151, 1, 0, 0.439525,-99) ,
7, -1.28555, 0, 0, 0.491606,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.395707,-99) ,
4, 0.999048, 0, 0, 0.488218,-99) );
// itree = 65
fBoostWeights.push_back(0.0331891);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 1.69384, 1, -1, 0.494492,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.535349,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.275546,-99) ,
8, -2.65458, 1, 0, 0.42812,-99) ,
7, -1.57142, 0, 0, 0.490257,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.390359,-99) ,
2, -0.214635, 0, 0, 0.485947,-99) );
// itree = 66
fBoostWeights.push_back(0.0374843);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.523803,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.49136,-99) ,
3, 0.978385, 1, 0, 0.498171,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.396785,-99) ,
3, 9.37272, 1, 0, 0.49482,-99) ,
NN(
0,
0,
-1, 0.499043, 1, -1, 0.42426,-99) ,
7, -1.57124, 0, 0, 0.490312,-99) );
// itree = 67
fBoostWeights.push_back(0.0252733);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.50156,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.435596,-99) ,
3, 9.37272, 1, 0, 0.499381,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.412554,-99) ,
7, 2.34685, 1, 0, 0.496663,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.527932,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.277594,-99) ,
9, -1.00135, 1, 0, 0.428761,-99) ,
7, -1.57127, 0, 0, 0.492278,-99) );
// itree = 68
fBoostWeights.push_back(0.0311902);
fForest.push_back(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.564453,-99) ,
NN(
0,
0,
-1, -0.319208, 1, -1, 0.487309,-99) ,
8, 1.74434, 0, 0, 0.49163,-99) );
// itree = 69
fBoostWeights.push_back(0.0548464);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.50705,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.45384,-99) ,
9, -1.58371, 0, 0, 0.502916,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.412535,-99) ,
3, 9.34253, 1, 0, 0.499727,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.589387,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.496842,-99) ,
9, -2.4722, 0, 0, 0.553999,-99) ,
NN(
0,
0,
-1, -1.60607, 1, -1, 0.328855,-99) ,
9, -1.29159, 1, 0, 0.456533,-99) ,
7, -0.999996, 0, 0, 0.492976,-99) );
// itree = 70
fBoostWeights.push_back(0.0341995);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.50441,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.467265,-99) ,
7, 1.47619, 1, 0, 0.499505,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.521429,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.312865,-99) ,
9, -1.00135, 1, 0, 0.434839,-99) ,
7, -1.57141, 0, 0, 0.495384,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.40057,-99) ,
2, -0.214257, 0, 0, 0.491294,-99) );
// itree = 71
fBoostWeights.push_back(0.056695);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.511314,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.458175,-99) ,
9, 1.06485, 1, 0, 0.501082,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.505429,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.380225,-99) ,
8, -2.32543, 0, 0, 0.469477,-99) ,
7, 0.823249, 1, 0, 0.491774,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.532299,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.299587,-99) ,
8, -2.65458, 1, 0, 0.438235,-99) ,
7, -1.57122, 0, 0, 0.488345,-99) );
// itree = 72
fBoostWeights.push_back(0.0363828);
fForest.push_back(
NN(
NN(
0,
0,
-1, 0.999048, 0, -1, 0.486714,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.516099,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.301545,-99) ,
8, -2.68861, 1, 0, 0.42885,-99) ,
7, -1.57122, 0, 0, 0.483032,-99) );
// itree = 73
fBoostWeights.push_back(0.0372162);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.557348,-99) ,
NN(
0,
0,
-1, -1.57125, 0, -1, 0.487407,-99) ,
8, 1.74434, 0, 0, 0.491379,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.402931,-99) ,
2, -0.214769, 0, 0, 0.48764,-99) );
// itree = 74
fBoostWeights.push_back(0.0395197);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.511556,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.44302,-99) ,
4, 0.999728, 0, 0, 0.508114,-99) ,
NN(
0,
0,
-1, -1.28573, 0, -1, 0.477597,-99) ,
0, 0.499043, 1, 0, 0.49539,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.416434,-99) ,
4, 0.999048, 0, 0, 0.492597,-99) );
// itree = 75
fBoostWeights.push_back(0.0355297);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.551906,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.496965,-99) ,
8, 1.76838, 0, 0, 0.500362,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.539899,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.347822,-99) ,
9, -1.59078, 1, 0, 0.446259,-99) ,
7, -1.28554, 0, 0, 0.494832,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.407137,-99) ,
4, 0.999048, 0, 0, 0.491847,-99) );
// itree = 76
fBoostWeights.push_back(0.0512168);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.518341,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.488799,-99) ,
8, -2.72398, 0, 0, 0.50609,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.546611,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.362719,-99) ,
9, -1.70024, 1, 0, 0.4538,-99) ,
7, -1.28552, 0, 0, 0.500712,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.409841,-99) ,
4, 0.999048, 0, 0, 0.497603,-99) );
// itree = 77
fBoostWeights.push_back(0.0328438);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.509111,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.48066,-99) ,
7, 1.04094, 1, 0, 0.502612,-99) ,
NN(
0,
0,
-1, 0.499043, 1, -1, 0.44619,-99) ,
7, -1.57117, 0, 0, 0.498995,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.424296,-99) ,
3, 9.07131, 1, 0, 0.496261,-99) );
// itree = 78
fBoostWeights.push_back(0.190904);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.00626777, 0, 1, 0.598791,-99) ,
NN(
0,
0,
-1, 0.00224987, 0, -1, 0.416971,-99) ,
5, 0.00337493, 0, 0, 0.500463,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.250877,-99) ,
5, 0.0236298, 1, 0, 0.494112,-99) );
// itree = 79
fBoostWeights.push_back(0.0821565);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.629701,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.510505,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.413866,-99) ,
7, 0.202796, 1, 0, 0.492587,-99) ,
1, -0.00532551, 1, 0, 0.506891,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.528758,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.475277,-99) ,
7, 0.87749, 1, 0, 0.50157,-99) ,
NN(
0,
0,
-1, -1.04089, 0, -1, 0.368426,-99) ,
7, -0.428605, 0, 0, 0.478884,-99) ,
9, -0.562581, 1, 0, 0.489958,-99) );
// itree = 80
fBoostWeights.push_back(0.0311866);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.501215,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.444192,-99) ,
4, 0.999728, 0, 0, 0.498361,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.545015,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.369541,-99) ,
8, -3.74704, 1, 0, 0.452439,-99) ,
7, -1.28571, 0, 0, 0.493593,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.405344,-99) ,
4, 0.999048, 0, 0, 0.490683,-99) );
// itree = 81
fBoostWeights.push_back(0.062137);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.531466,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.492004,-99) ,
8, -1.98735, 0, 0, 0.502867,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.546471,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.352491,-99) ,
9, -1.34326, 1, 0, 0.469573,-99) ,
7, -0.99987, 0, 0, 0.497143,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.526133,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.453876,-99) ,
8, 1.86149, 0, 0, 0.477226,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.376973,-99) ,
2, -0.0730242, 0, 0, 0.46057,-99) ,
9, 1.74667, 1, 0, 0.491409,-99) );
// itree = 82
fBoostWeights.push_back(0.0426946);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.507222,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.389726,-99) ,
9, -2.10404, 0, 0, 0.502849,-99) ,
NN(
0,
0,
-1, 0.143014, 0, -1, 0.470624,-99) ,
9, 1.36388, 1, 0, 0.495856,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.527178,-99) ,
NN(
0,
0,
-1, -2.54949, 1, -1, 0.389922,-99) ,
6, -951.286, 0, 0, 0.445927,-99) ,
7, -1.28546, 0, 0, 0.490716,-99) );
// itree = 83
fBoostWeights.push_back(0.140768);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -1.14454, 1, 1, 0.620896,-99) ,
NN(
0,
0,
-1, 0.00161705, 0, -1, 0.453252,-99) ,
5, 0.00565966, 0, 0, 0.494744,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.244574,-99) ,
5, 0.0237713, 1, 0, 0.488403,-99) );
// itree = 84
fBoostWeights.push_back(0.0256934);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.561085,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.481128,-99) ,
3, 4.71064, 1, 0, 0.532865,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.501302,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.46108,-99) ,
2, -0.22828, 0, 0, 0.499384,-99) ,
2, 0.0709021, 0, 0, 0.504666,-99) ,
NN(
0,
0,
-1, -2.04761, 0, -1, 0.443386,-99) ,
7, -1.57141, 0, 0, 0.500798,-99) );
// itree = 85
fBoostWeights.push_back(0.0388006);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.533668,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.499506,-99) ,
2, 0.0705056, 0, 0, 0.504492,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.408482,-99) ,
4, 0.999048, 0, 0, 0.501213,-99) ,
NN(
NN(
0,
0,
-1, 0.498088, 1, 1, 0.543203,-99) ,
NN(
0,
0,
-1, 0.220477, 1, -1, 0.383423,-99) ,
8, -3.61433, 1, 0, 0.462987,-99) ,
7, -0.999851, 0, 0, 0.495294,-99) );
// itree = 86
fBoostWeights.push_back(0.0406289);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.514392,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.4825,-99) ,
9, 1.38757, 1, 0, 0.507459,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.436681,-99) ,
3, 9.39986, 1, 0, 0.505137,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.514173,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.398469,-99) ,
8, -3.04736, 1, 0, 0.463896,-99) ,
7, -1.2857, 0, 0, 0.500891,-99) );
// itree = 87
fBoostWeights.push_back(0.0335094);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.0305955, 0, 1, 0.508203,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.546283,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.411513,-99) ,
6, -951.286, 0, 0, 0.464971,-99) ,
7, -1.28558, 0, 0, 0.503804,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.436531,-99) ,
2, -0.214218, 0, 0, 0.500937,-99) );
// itree = 88
fBoostWeights.push_back(0.0175728);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.501157,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.431381,-99) ,
4, 0.999048, 0, 0, 0.49891,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.440531,-99) ,
9, -2.09617, 0, 0, 0.495571,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.432449,-99) ,
7, -1.85696, 0, 0, 0.493249,-99) );
// itree = 89
fBoostWeights.push_back(0.0409612);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.505692,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.466315,-99) ,
9, 2.36854, 1, 0, 0.50134,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.458509,-99) ,
7, 2.04757, 1, 0, 0.498763,-99) ,
NN(
NN(
0,
0,
-1, -4.6656, 0, 1, 0.536841,-99) ,
NN(
0,
0,
-1, -1.81218, 1, -1, 0.390026,-99) ,
8, -3.61433, 1, 0, 0.463283,-99) ,
7, -1.00001, 0, 0, 0.493268,-99) );
// itree = 90
fBoostWeights.push_back(0.0442367);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.523988,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.495143,-99) ,
9, -1.02218, 1, 0, 0.501871,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.516839,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.481222,-99) ,
8, 1.4113, 0, 0, 0.483653,-99) ,
0, 0.497138, 1, 0, 0.490964,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.543875,-99) ,
NN(
0,
0,
-1, -0.847411, 1, -1, 0.382492,-99) ,
6, -951.287, 0, 0, 0.450966,-99) ,
7, -1.2857, 0, 0, 0.486928,-99) );
// itree = 91
fBoostWeights.push_back(0.0330554);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.515687,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.49945,-99) ,
9, 0.548295, 1, 0, 0.509963,-99) ,
NN(
0,
0,
-1, 1.82585, 1, -1, 0.48744,-99) ,
0, 0.49809, 1, 0, 0.4986,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.523554,-99) ,
NN(
0,
0,
-1, -1.7753, 0, -1, 0.412239,-99) ,
6, -951.286, 0, 0, 0.457695,-99) ,
7, -1.28552, 0, 0, 0.49447,-99) );
// itree = 92
fBoostWeights.push_back(0.0716411);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.570972,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.465408,-99) ,
9, -2.2175, 0, 0, 0.537723,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.389145,-99) ,
7, -0.297899, 1, 0, 0.510558,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.507466,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.418049,-99) ,
4, 0.999524, 0, 0, 0.502643,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.50123,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.365269,-99) ,
6, -951.286, 0, 0, 0.410467,-99) ,
7, -0.428435, 0, 0, 0.485992,-99) ,
9, -1.20329, 1, 0, 0.491699,-99) );
// itree = 93
fBoostWeights.push_back(0.0695461);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.52581,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.466553,-99) ,
7, 0.170169, 0, 0, 0.510579,-99) ,
NN(
0,
0,
-1, -1.68833, 0, -1, 0.482508,-99) ,
8, -2.27244, 0, 0, 0.4961,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.551336,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.44004,-99) ,
9, -2.43965, 0, 0, 0.520026,-99) ,
NN(
0,
0,
-1, 0.499995, 1, -1, 0.384007,-99) ,
9, -0.927949, 1, 0, 0.468132,-99) ,
7, -0.714278, 0, 0, 0.489876,-99) );
// itree = 94
fBoostWeights.push_back(0.0247442);
fForest.push_back(
NN(
NN(
0,
0,
-1, 0.42836, 0, 1, 0.54088,-99) ,
NN(
0,
0,
-1, -0.237824, 1, -1, 0.489771,-99) ,
8, 1.33504, 0, 0, 0.49334,-99) );
// itree = 95
fBoostWeights.push_back(0.0436083);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -3.2968, 1, 1, 0.56688,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.532989,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.493767,-99) ,
2, 0.0739516, 0, 0, 0.498975,-99) ,
4, 0.999524, 1, 0, 0.50402,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.540153,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.476627,-99) ,
6, -951.286, 0, 0, 0.502654,-99) ,
NN(
0,
0,
-1, 2.63063, 0, -1, 0.427964,-99) ,
7, 0.142953, 0, 0, 0.478147,-99) ,
9, 0.969131, 1, 0, 0.49731,-99) );
// itree = 96
fBoostWeights.push_back(0.0477947);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.621009,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.508245,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.408043,-99) ,
7, 0.796693, 1, 0, 0.499122,-99) ,
1, -0.00649323, 1, 0, 0.508491,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.506264,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.455525,-99) ,
2, -0.0716622, 0, 0, 0.497705,-99) ,
NN(
0,
0,
-1, -0.0333454, 0, -1, 0.397271,-99) ,
7, -0.714145, 0, 0, 0.48533,-99) ,
9, -0.0485644, 1, 0, 0.497656,-99) );
// itree = 97
fBoostWeights.push_back(0.0332485);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.999524, 1, 1, 0.5037,-99) ,
NN(
0,
0,
-1, -2.13423, 0, -1, 0.449212,-99) ,
7, 1.31119, 1, 0, 0.498733,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.521541,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.475441,-99) ,
6, -951.286, 0, 0, 0.494358,-99) ,
NN(
0,
0,
-1, 2.03824, 0, -1, 0.408639,-99) ,
7, -0.142516, 0, 0, 0.473062,-99) ,
9, 0.926524, 1, 0, 0.491863,-99) );
// itree = 98
fBoostWeights.push_back(0.13128);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.00734004, 0, 1, 0.549317,-99) ,
NN(
0,
0,
-1, 0.00128583, 0, -1, 0.419359,-99) ,
5, 0.00225021, 0, 0, 0.498786,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.288354,-99) ,
5, 0.0236295, 1, 0, 0.493504,-99) );
// itree = 99
fBoostWeights.push_back(0.0386965);
fForest.push_back(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.536297,-99) ,
NN(
NN(
0,
0,
-1, 2.14284, 1, -1, 0.492827,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.568522,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.400942,-99) ,
6, -951.286, 0, 0, 0.453865,-99) ,
8, -0.465866, 1, 0, 0.487488,-99) ,
8, 2.07703, 0, 0, 0.489939,-99) );
// itree = 100
fBoostWeights.push_back(0.0471182);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.552112,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.515073,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.485916,-99) ,
6, -951.286, 1, 0, 0.499459,-99) ,
4, 0.999524, 1, 0, 0.503293,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.51545,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.436339,-99) ,
2, -0.0732342, 0, 0, 0.503007,-99) ,
NN(
0,
0,
-1, -951.286, 0, -1, 0.440806,-99) ,
7, 0.428682, 0, 0, 0.477674,-99) ,
9, 0.71673, 1, 0, 0.495459,-99) );
// itree = 101
fBoostWeights.push_back(0.0485264);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.508794,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.429936,-99) ,
9, -1.79368, 0, 0, 0.504291,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.509418,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.449178,-99) ,
7, 1.09544, 0, 0, 0.472405,-99) ,
9, 1.61761, 1, 0, 0.498188,-99) ,
NN(
NN(
0,
0,
-1, 0.498092, 1, 1, 0.534205,-99) ,
NN(
0,
0,
-1, -1.66645, 0, -1, 0.401484,-99) ,
8, -3.64317, 1, 0, 0.468472,-99) ,
7, -0.999763, 0, 0, 0.493601,-99) );
// itree = 102
fBoostWeights.push_back(0.0226473);
fForest.push_back(
NN(
0,
0,
-1, -1.57141, 0, -1, 0.488678,-99) );
// itree = 103
fBoostWeights.push_back(0.0437657);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.999524, 1, 1, 0.510879,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.417569,-99) ,
7, 0.760049, 1, 0, 0.502733,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.50876,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.465027,-99) ,
7, 1.95242, 1, 0, 0.501744,-99) ,
NN(
0,
0,
-1, 0.956457, 0, -1, 0.42652,-99) ,
7, -0.142733, 0, 0, 0.484387,-99) ,
9, -0.108208, 1, 0, 0.493856,-99) );
// itree = 104
fBoostWeights.push_back(0.0453357);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.558166,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.525561,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.483725,-99) ,
2, 0.0572558, 0, 0, 0.48936,-99) ,
4, 0.999524, 1, 0, 0.493221,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.500102,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.412017,-99) ,
2, -0.153281, 0, 0, 0.480641,-99) ,
NN(
0,
0,
-1, -0.254302, 1, -1, 0.426081,-99) ,
2, 0.0710848, 1, 0, 0.465826,-99) ,
3, 4.69334, 1, 0, 0.487839,-99) );
// itree = 105
fBoostWeights.push_back(0.0220567);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.504212,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.476492,-99) ,
9, -2.21706, 0, 0, 0.502603,-99) ,
NN(
0,
0,
-1, 4.72918, 1, -1, 0.482413,-99) ,
0, 0.500947, 1, 0, 0.497434,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.423127,-99) ,
2, 0.21376, 1, 0, 0.494657,-99) );
// itree = 106
fBoostWeights.push_back(0.046947);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.534035,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.47737,-99) ,
9, -2.25123, 0, 0, 0.523903,-99) ,
NN(
0,
0,
-1, -0.930178, 0, -1, 0.440951,-99) ,
7, 0.136604, 1, 0, 0.508837,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.500531,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.449584,-99) ,
7, 2.34694, 1, 0, 0.49769,-99) ,
NN(
0,
0,
-1, -0.673365, 0, -1, 0.426022,-99) ,
7, -0.428444, 0, 0, 0.485383,-99) ,
9, -0.645359, 1, 0, 0.494134,-99) );
// itree = 107
fBoostWeights.push_back(0.0328132);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.521894,-99) ,
NN(
0,
0,
-1, 1.54331, 1, -1, 0.485681,-99) ,
8, 1.8082, 0, 0, 0.487708,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.441803,-99) ,
2, 0.214029, 1, 0, 0.485956,-99) );
// itree = 108
fBoostWeights.push_back(0.0352412);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.544461,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.523797,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.48894,-99) ,
3, 0.55578, 1, 0, 0.492343,-99) ,
4, 0.999524, 1, 0, 0.495215,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.504904,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.422537,-99) ,
2, 0.153129, 1, 0, 0.487918,-99) ,
NN(
0,
0,
-1, 0.499044, 1, -1, 0.440957,-99) ,
2, -0.0713365, 0, 0, 0.474101,-99) ,
3, 4.59902, 1, 0, 0.490902,-99) );
// itree = 109
fBoostWeights.push_back(0.0525363);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -2.98257, 1, 1, 0.53731,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.523569,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.477528,-99) ,
2, -0.00891315, 1, 0, 0.497876,-99) ,
2, 0.0650737, 0, 0, 0.503174,-99) ,
NN(
0,
0,
-1, 0.502852, 1, -1, 0.46822,-99) ,
3, 4.68797, 1, 0, 0.496285,-99) );
// itree = 110
fBoostWeights.push_back(0.0462807);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.526837,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.460158,-99) ,
7, -0.0407133, 1, 0, 0.508467,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.501411,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.435598,-99) ,
7, -0.142851, 0, 0, 0.485955,-99) ,
9, -0.59558, 1, 0, 0.494592,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.431572,-99) ,
3, 9.39196, 1, 0, 0.492617,-99) );
// itree = 111
fBoostWeights.push_back(0.0335299);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.522196,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.496305,-99) ,
2, -0.0718876, 1, 0, 0.500348,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.538745,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.455488,-99) ,
6, -951.286, 0, 0, 0.485561,-99) ,
8, -1.04645, 1, 0, 0.496769,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.440621,-99) ,
4, 0.999048, 0, 0, 0.494862,-99) );
// itree = 112
fBoostWeights.push_back(0.0354119);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.999524, 1, 1, 0.512512,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.429618,-99) ,
7, 0.77807, 1, 0, 0.505367,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.501109,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.471358,-99) ,
8, -1.88293, 0, 0, 0.492454,-99) ,
NN(
0,
0,
-1, 1.31975, 0, -1, 0.416436,-99) ,
7, -0.714082, 0, 0, 0.48347,-99) ,
9, -0.092933, 1, 0, 0.494915,-99) );
// itree = 113
fBoostWeights.push_back(0.0458974);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.999524, 1, 1, 0.513525,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.508496,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.414414,-99) ,
6, -951.286, 1, 0, 0.451427,-99) ,
7, 0.514875, 1, 0, 0.503745,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.509364,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.477286,-99) ,
7, 1.36737, 1, 0, 0.496069,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.505846,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.425114,-99) ,
6, -951.286, 0, 0, 0.453024,-99) ,
7, 0.142916, 0, 0, 0.482967,-99) ,
9, -0.138381, 1, 0, 0.493578,-99) );
// itree = 114
fBoostWeights.push_back(0.0313248);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.532944,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.472064,-99) ,
9, 0.756735, 1, 0, 0.51344,-99) ,
NN(
0,
0,
-1, -1.57112, 0, -1, 0.493492,-99) ,
3, 0.766417, 1, 0, 0.496978,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.510289,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.446139,-99) ,
2, 0.0774861, 1, 0, 0.486522,-99) ,
NN(
0,
0,
-1, 0.144522, 1, -1, 0.441127,-99) ,
2, -0.0720886, 0, 0, 0.473125,-99) ,
3, 4.7423, 1, 0, 0.492419,-99) );
// itree = 115
fBoostWeights.push_back(0.065578);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.528178,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.469281,-99) ,
4, 0.999994, 0, 0, 0.499723,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.521971,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.415514,-99) ,
9, -0.645359, 1, 0, 0.470584,-99) ,
4, 0.999864, 0, 0, 0.497003,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.431566,-99) ,
4, 0.999048, 0, 0, 0.494851,-99) );
// itree = 116
fBoostWeights.push_back(0.0423538);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.512274,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.474536,-99) ,
4, 0.999991, 0, 0, 0.495656,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.506384,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.40587,-99) ,
9, -0.469166, 1, 0, 0.4629,-99) ,
4, 0.999819, 0, 0, 0.493248,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.44574,-99) ,
4, 0.999048, 0, 0, 0.49165,-99) );
// itree = 117
fBoostWeights.push_back(0.014759);
fForest.push_back(
NN(
0,
0,
-1, 0.489519, 0, -1, 0.492621,-99) );
// itree = 118
fBoostWeights.push_back(0.0352359);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.559393,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.528591,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.489274,-99) ,
2, 0.0572558, 0, 0, 0.494605,-99) ,
4, 0.999524, 1, 0, 0.498358,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.501834,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.459173,-99) ,
7, 0.700748, 1, 0, 0.484701,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.448593,-99) ,
7, -0.714111, 0, 0, 0.476694,-99) ,
3, 4.7423, 1, 0, 0.494152,-99) );
// itree = 119
fBoostWeights.push_back(0.0909344);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -0.648218, 1, 1, 0.618722,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.501101,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.434864,-99) ,
5, 0.00159743, 0, 0, 0.477917,-99) ,
5, 0.00670918, 0, 0, 0.504441,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.307369,-99) ,
5, 0.0234841, 1, 0, 0.499366,-99) );
// itree = 120
fBoostWeights.push_back(0.0236457);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.50181,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.442613,-99) ,
9, -2.15581, 0, 0, 0.497951,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.510206,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.467114,-99) ,
8, 1.23966, 0, 0, 0.480978,-99) ,
9, 1.20369, 1, 0, 0.493979,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.442872,-99) ,
7, -1.85696, 0, 0, 0.492161,-99) );
// itree = 121
fBoostWeights.push_back(0.0350033);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.53569,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.526297,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.492114,-99) ,
2, -0.0447539, 1, 0, 0.498156,-99) ,
4, 0.999524, 1, 0, 0.500235,-99) ,
NN(
0,
0,
-1, 0.502852, 1, -1, 0.461484,-99) ,
3, 4.73378, 1, 0, 0.492797,-99) );
// itree = 122
fBoostWeights.push_back(0.0310319);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.537005,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.479275,-99) ,
9, 0.994311, 1, 0, 0.52067,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.503013,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.488958,-99) ,
3, 2.27231, 0, 0, 0.495133,-99) ,
3, 0.757551, 1, 0, 0.499562,-99) ,
NN(
0,
0,
-1, 1.03761, 1, -1, 0.469299,-99) ,
3, 4.73378, 1, 0, 0.49366,-99) );
// itree = 123
fBoostWeights.push_back(0.037791);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.572044,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.48693,-99) ,
2, -0.0084594, 1, 0, 0.510665,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.517154,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.489473,-99) ,
2, 0.0744558, 0, 0, 0.493616,-99) ,
3, 1.00335, 1, 0, 0.498136,-99) ,
NN(
0,
0,
-1, 0.493331, 0, -1, 0.470078,-99) ,
3, 4.75772, 1, 0, 0.492793,-99) );
// itree = 124
fBoostWeights.push_back(0.0427972);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.545238,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.484292,-99) ,
9, 0.657064, 1, 0, 0.523541,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.525541,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.484318,-99) ,
2, 0.0245516, 0, 0, 0.496766,-99) ,
2, -0.0491828, 1, 0, 0.50159,-99) ,
NN(
0,
0,
-1, 1.04468, 1, -1, 0.479295,-99) ,
3, 4.68186, 1, 0, 0.497174,-99) );
// itree = 125
fBoostWeights.push_back(0.0243489);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.535473,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.511186,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.491877,-99) ,
6, -951.286, 0, 0, 0.501432,-99) ,
8, 1.90004, 0, 0, 0.503324,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.460229,-99) ,
2, 0.213932, 1, 0, 0.501676,-99) );
// itree = 126
fBoostWeights.push_back(0.0490065);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.526031,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.482967,-99) ,
4, 0.999994, 0, 0, 0.505064,-99) ,
NN(
0,
0,
-1, -0.519326, 1, -1, 0.463466,-99) ,
4, 0.999864, 0, 0, 0.501203,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.432724,-99) ,
4, 0.999048, 0, 0, 0.498956,-99) );
// itree = 127
fBoostWeights.push_back(0.0226353);
fForest.push_back(
NN(
NN(
0,
0,
-1, 0.498085, 0, 1, 0.531393,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.504679,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.447601,-99) ,
4, 0.999048, 0, 0, 0.502824,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.406446,-99) ,
7, -1.57122, 0, 0, 0.498845,-99) ,
8, -4.41746, 1, 0, 0.501081,-99) );
// itree = 128
fBoostWeights.push_back(0.0366243);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.522836,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.478076,-99) ,
3, 4.70919, 1, 0, 0.50983,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.511266,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.482736,-99) ,
2, 0.0176164, 0, 0, 0.49421,-99) ,
2, -0.0289772, 1, 0, 0.498693,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.449056,-99) ,
2, 0.215626, 1, 0, 0.496881,-99) );
// itree = 129
fBoostWeights.push_back(0.0298961);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.50628,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.42543,-99) ,
7, -1.57141, 0, 0, 0.502577,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.455315,-99) ,
9, -2.52665, 0, 0, 0.500783,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.534272,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.476557,-99) ,
7, 0.713969, 0, 0, 0.498762,-99) ,
NN(
0,
0,
-1, 0.457842, 0, -1, 0.435543,-99) ,
8, 1.12809, 0, 0, 0.472606,-99) ,
9, 2.06512, 1, 0, 0.4971,-99) );
// itree = 130
fBoostWeights.push_back(0.071462);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.569788,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.520606,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.482643,-99) ,
6, -951.286, 1, 0, 0.499522,-99) ,
4, 0.999524, 1, 0, 0.505108,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.542277,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.351803,-99) ,
6, -1.28575, 0, 0, 0.50833,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.545869,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.460158,-99) ,
9, 3.13159, 0, 0, 0.471205,-99) ,
6, -951.286, 0, 0, 0.487209,-99) ,
9, -0.108208, 1, 0, 0.49649,-99) );
// itree = 131
fBoostWeights.push_back(0.0295078);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.508836,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.485338,-99) ,
4, 0.999987, 0, 0, 0.499936,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.443281,-99) ,
4, 0.999728, 0, 0, 0.497185,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.441405,-99) ,
4, 0.999048, 0, 0, 0.495353,-99) );
// itree = 132
fBoostWeights.push_back(0.0188458);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 9.13835, 0, 1, 0.502831,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.430074,-99) ,
4, 0.999773, 0, 0, 0.500175,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.544678,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.383592,-99) ,
8, -3.09051, 1, 0, 0.466817,-99) ,
4, 0.999524, 0, 0, 0.49831,-99) );
// itree = 133
fBoostWeights.push_back(0.0419003);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.545806,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.502159,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.387908,-99) ,
7, 0.751195, 1, 0, 0.492429,-99) ,
8, -2.54336, 0, 0, 0.497923,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.5067,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.472578,-99) ,
8, -1.88188, 0, 0, 0.495429,-99) ,
NN(
0,
0,
-1, -951.286, 0, -1, 0.441052,-99) ,
7, 0.143012, 0, 0, 0.478984,-99) ,
9, -0.108208, 1, 0, 0.488802,-99) );
// itree = 134
fBoostWeights.push_back(0.0182808);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.533463,-99) ,
NN(
0,
0,
-1, 3.27185, 1, -1, 0.493156,-99) ,
7, 2.14286, 0, 0, 0.494895,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.458092,-99) ,
4, 0.999048, 0, 0, 0.493649,-99) );
// itree = 135
fBoostWeights.push_back(0.0455171);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.461952, 1, 1, 0.556549,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.52886,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.48999,-99) ,
2, -0.0714192, 1, 0, 0.496607,-99) ,
8, -1.70632, 0, 0, 0.501446,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.552251,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.471223,-99) ,
6, -951.286, 0, 0, 0.506289,-99) ,
NN(
0,
0,
-1, 3.46954, 1, -1, 0.463433,-99) ,
7, 1.00007, 0, 0, 0.481507,-99) ,
9, 0.795688, 1, 0, 0.495683,-99) );
// itree = 136
fBoostWeights.push_back(0.022665);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.567408,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.486679,-99) ,
9, -2.40968, 0, 0, 0.527904,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.500355,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.406928,-99) ,
7, -1.57123, 0, 0, 0.496058,-99) ,
8, -4.3854, 1, 0, 0.498878,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.503934,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.450348,-99) ,
8, 0.343449, 0, 0, 0.486593,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.435144,-99) ,
0, 0.5019, 1, 0, 0.475946,-99) ,
9, 1.64431, 1, 0, 0.494955,-99) );
// itree = 137
fBoostWeights.push_back(0.0219283);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.576978,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.497614,-99) ,
3, 9.09389, 0, 0, 0.500153,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.438635,-99) ,
4, 0.999796, 0, 0, 0.497502,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.529985,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.371865,-99) ,
8, -2.99452, 1, 0, 0.45767,-99) ,
4, 0.999524, 0, 0, 0.495293,-99) );
// itree = 138
fBoostWeights.push_back(0.0400514);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.59526,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.486887,-99) ,
7, 0.093531, 0, 0, 0.537519,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.593049,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.49001,-99) ,
1, -0.00581658, 1, 0, 0.499152,-99) ,
8, -2.31229, 0, 0, 0.504422,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.500588,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.395324,-99) ,
2, -0.150962, 0, 0, 0.492227,-99) ,
NN(
0,
0,
-1, 0.499042, 0, -1, 0.438973,-99) ,
2, 0.0731616, 1, 0, 0.48435,-99) ,
9, 0.360757, 1, 0, 0.496972,-99) );
// itree = 139
fBoostWeights.push_back(0.0236309);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -4.34118, 1, 1, 0.50728,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.461742,-99) ,
7, 1.49701, 1, 0, 0.504874,-99) ,
NN(
0,
0,
-1, -0.0716874, 0, -1, 0.480869,-99) ,
9, 0.842378, 1, 0, 0.498066,-99) );
// itree = 140
fBoostWeights.push_back(0.0186804);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.289894, 1, 1, 0.537001,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.502739,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.48916,-99) ,
9, 0.341677, 1, 0, 0.497604,-99) ,
3, 0.536618, 1, 0, 0.500619,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.454805,-99) ,
3, 9.37272, 1, 0, 0.499196,-99) );
// itree = 141
fBoostWeights.push_back(0.0172146);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.528161,-99) ,
NN(
0,
0,
-1, -1.57143, 0, -1, 0.497174,-99) ,
8, -4.42342, 1, 0, 0.499659,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.507028,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.503354,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.450253,-99) ,
7, -0.345531, 1, 0, 0.464177,-99) ,
7, 1.28643, 0, 0, 0.476725,-99) ,
9, 1.74667, 1, 0, 0.496042,-99) );
// itree = 142
fBoostWeights.push_back(0.0234523);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -951.287, 0, 1, 0.531753,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.524456,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.497158,-99) ,
2, 0.0630807, 0, 0, 0.501304,-99) ,
3, 0.54321, 1, 0, 0.504164,-99) ,
NN(
0,
0,
-1, 9.11214, 1, -1, 0.474952,-99) ,
3, 4.71771, 1, 0, 0.498518,-99) );
// itree = 143
fBoostWeights.push_back(0.0192931);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -4.63091, 1, 1, 0.504792,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.461092,-99) ,
7, 1.57389, 1, 0, 0.502743,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.505225,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.454735,-99) ,
2, -0.0742129, 0, 0, 0.495578,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.447583,-99) ,
2, 0.0750122, 1, 0, 0.488738,-99) ,
9, 0.926524, 1, 0, 0.498983,-99) );
// itree = 144
fBoostWeights.push_back(0.0374804);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -2.39469, 0, 1, 0.546582,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.539242,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.390654,-99) ,
9, -1.61841, 0, 0, 0.473941,-99) ,
7, -0.769381, 1, 0, 0.515505,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.50382,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.462069,-99) ,
4, 0.999524, 0, 0, 0.501535,-99) ,
NN(
0,
0,
-1, -1.66672, 0, -1, 0.437778,-99) ,
7, -0.99999, 0, 0, 0.495205,-99) ,
8, -3.83621, 1, 0, 0.498533,-99) );
// itree = 145
fBoostWeights.push_back(0.0277857);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.570524,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.475212,-99) ,
6, -951.286, 1, 0, 0.514525,-99) ,
NN(
0,
0,
-1, -0.99999, 0, -1, 0.492397,-99) ,
8, -3.91596, 1, 0, 0.495633,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.458285,-99) ,
3, 9.10638, 1, 0, 0.494321,-99) );
// itree = 146
fBoostWeights.push_back(0.0437885);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.538613,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.466815,-99) ,
7, -0.350231, 1, 0, 0.514814,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.508581,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.449869,-99) ,
7, -0.714298, 0, 0, 0.499697,-99) ,
8, -3.48502, 1, 0, 0.503707,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.5121,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.449247,-99) ,
7, 1.01187, 0, 0, 0.474007,-99) ,
9, 2.77661, 1, 0, 0.501323,-99) );
// itree = 147
fBoostWeights.push_back(0.0269998);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.529671,-99) ,
NN(
0,
0,
-1, -1.57127, 0, -1, 0.493091,-99) ,
8, -4.62858, 1, 0, 0.495183,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.527505,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.460528,-99) ,
6, -951.286, 1, 0, 0.499019,-99) ,
NN(
0,
0,
-1, 2.16075, 1, -1, 0.445884,-99) ,
8, 0.746509, 0, 0, 0.477096,-99) ,
9, 1.74667, 1, 0, 0.492309,-99) );
// itree = 148
fBoostWeights.push_back(0.0178017);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.549579, 1, 1, 0.504543,-99) ,
NN(
0,
0,
-1, 1.44508, 0, -1, 0.47402,-99) ,
9, 2.77661, 1, 0, 0.502008,-99) ,
NN(
0,
0,
-1, 1.03761, 1, -1, 0.480436,-99) ,
3, 4.72382, 1, 0, 0.497811,-99) );
// itree = 149
fBoostWeights.push_back(0.0248475);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.508944,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.489374,-99) ,
4, 0.999987, 0, 0, 0.501593,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.454405,-99) ,
4, 0.999728, 0, 0, 0.499315,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.455647,-99) ,
4, 0.999048, 0, 0, 0.497853,-99) );
// itree = 150
fBoostWeights.push_back(0.0211045);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.563614,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.507365,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.450489,-99) ,
9, -2.09339, 0, 0, 0.478044,-99) ,
6, -951.286, 1, 0, 0.512019,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.500748,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.4466,-99) ,
4, 0.999048, 0, 0, 0.498987,-99) ,
NN(
0,
0,
-1, -1.66649, 0, -1, 0.464435,-99) ,
7, -0.999821, 0, 0, 0.495414,-99) ,
8, -4.02043, 1, 0, 0.497514,-99) );
// itree = 151
fBoostWeights.push_back(0.097863);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -0.480915, 1, 1, 0.632314,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.50962,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.449721,-99) ,
5, 0.00262898, 0, 0, 0.478811,-99) ,
5, 0.00788689, 0, 0, 0.500636,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.305234,-99) ,
5, 0.0236624, 1, 0, 0.495714,-99) );
// itree = 152
fBoostWeights.push_back(0.0281309);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.545093,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.493984,-99) ,
4, 0.999524, 1, 0, 0.497107,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.450426,-99) ,
3, 9.34278, 1, 0, 0.495484,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.526019,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.466889,-99) ,
9, 4.14422, 1, 0, 0.499114,-99) ,
NN(
0,
0,
-1, 2.45146, 1, -1, 0.44367,-99) ,
8, 1.12289, 0, 0, 0.475473,-99) ,
9, 2.01783, 1, 0, 0.492752,-99) );
// itree = 153
fBoostWeights.push_back(0.0313463);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.585381,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.475196,-99) ,
7, 0.428517, 0, 0, 0.52289,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.503683,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.460978,-99) ,
7, 1.28504, 1, 0, 0.499241,-99) ,
8, -1.60831, 0, 0, 0.502523,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.510843,-99) ,
NN(
0,
0,
-1, -0.0349287, 0, -1, 0.47119,-99) ,
7, 1.57148, 0, 0, 0.480944,-99) ,
9, 1.34887, 1, 0, 0.498101,-99) );
// itree = 154
fBoostWeights.push_back(0.0814207);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -0.541537, 1, 1, 0.6085,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.510686,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.469347,-99) ,
5, 0.00412535, 0, 0, 0.480374,-99) ,
5, 0.00787574, 0, 0, 0.498381,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.320116,-99) ,
5, 0.0236298, 1, 0, 0.493883,-99) );
// itree = 155
fBoostWeights.push_back(0.081139);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.524299,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.475546,-99) ,
9, -2.30691, 0, 0, 0.517391,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.512888,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.37891,-99) ,
9, -0.807404, 0, 0, 0.469166,-99) ,
7, 0.258873, 1, 0, 0.508617,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.549294,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.371268,-99) ,
6, -1.00023, 0, 0, 0.507162,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.543596,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.467539,-99) ,
8, 0.961201, 0, 0, 0.479157,-99) ,
6, -951.286, 0, 0, 0.491691,-99) ,
9, -0.453124, 1, 0, 0.498948,-99) );
// itree = 156
fBoostWeights.push_back(0.0310899);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.542842,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.439659,-99) ,
4, 0.999955, 0, 0, 0.51866,-99) ,
NN(
0,
0,
-1, 2.60994, 1, -1, 0.491853,-99) ,
7, 1.28571, 0, 0, 0.496056,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.445206,-99) ,
4, 0.999048, 0, 0, 0.494415,-99) );
// itree = 157
fBoostWeights.push_back(0.0273869);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.528552,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.492764,-99) ,
3, 0.82536, 1, 0, 0.520165,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.513406,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.491264,-99) ,
0, 0.494282, 1, 0, 0.495446,-99) ,
3, 0.993631, 1, 0, 0.500862,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.45444,-99) ,
3, 9.38661, 1, 0, 0.499425,-99) );
// itree = 158
fBoostWeights.push_back(0.0186526);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.505529,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.454368,-99) ,
4, 0.999728, 0, 0, 0.503116,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.473012,-99) ,
4, 0.999048, 0, 0, 0.502156,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.457517,-99) ,
0, 0.505709, 1, 0, 0.500497,-99) );
// itree = 159
fBoostWeights.push_back(0.0185167);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.570739,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.492695,-99) ,
6, -951.286, 1, 0, 0.522479,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.502367,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.467664,-99) ,
9, 2.76361, 1, 0, 0.499161,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.44752,-99) ,
7, -1.57127, 0, 0, 0.496966,-99) ,
8, -4.28007, 1, 0, 0.499175,-99) );
// itree = 160
fBoostWeights.push_back(0.0449179);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.571933,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.476867,-99) ,
7, 0.139746, 0, 0, 0.525291,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.572224,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.487995,-99) ,
1, 0.00652116, 0, 0, 0.494812,-99) ,
8, -1.64617, 0, 0, 0.499272,-99) ,
NN(
0,
0,
-1, -0.0712726, 0, -1, 0.473665,-99) ,
9, 1.33432, 1, 0, 0.493983,-99) );
// itree = 161
fBoostWeights.push_back(0.016204);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 9.09389, 0, 1, 0.505,-99) ,
NN(
0,
0,
-1, -0.30228, 1, -1, 0.469558,-99) ,
4, 0.999819, 0, 0, 0.502457,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.453382,-99) ,
4, 0.999048, 0, 0, 0.500883,-99) );
// itree = 162
fBoostWeights.push_back(0.024803);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.552776,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.536282,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.430802,-99) ,
9, -1.96604, 0, 0, 0.490859,-99) ,
7, -1.23754, 1, 0, 0.515418,-99) ,
NN(
0,
0,
-1, -1.57126, 0, -1, 0.492932,-99) ,
8, -4.06022, 1, 0, 0.495638,-99) );
// itree = 163
fBoostWeights.push_back(0.018373);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -1.57141, 1, 1, 0.50676,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.4697,-99) ,
0, 0.489927, 0, 0, 0.505437,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.500215,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.466567,-99) ,
3, 1.54046, 0, 0, 0.487033,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.445547,-99) ,
3, 4.38993, 1, 0, 0.476071,-99) ,
0, 0.503804, 1, 0, 0.502618,-99) );
// itree = 164
fBoostWeights.push_back(0.0533409);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.522982,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.474158,-99) ,
7, -0.714155, 0, 0, 0.511312,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.514071,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.274782,-99) ,
6, -1.85634, 0, 0, 0.49464,-99) ,
6, -951.286, 1, 0, 0.503175,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.507669,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.467108,-99) ,
0, 0.495234, 0, 0, 0.498603,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.441165,-99) ,
9, 1.05469, 1, 0, 0.485495,-99) ,
3, 4.69981, 1, 0, 0.499761,-99) );
// itree = 165
fBoostWeights.push_back(0.0196999);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.506616,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.493667,-99) ,
7, 0.183713, 0, 0, 0.499424,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.455253,-99) ,
7, 2.14281, 1, 0, 0.497787,-99) ,
NN(
0,
0,
-1, 1.80898, 0, -1, 0.467903,-99) ,
9, 2.77661, 1, 0, 0.495356,-99) );
// itree = 166
fBoostWeights.push_back(0.0202699);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.557408,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.503559,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.45222,-99) ,
7, -0.869688, 1, 0, 0.479265,-99) ,
6, -951.286, 1, 0, 0.510253,-99) ,
NN(
0,
0,
-1, -1.57141, 0, -1, 0.494547,-99) ,
8, -3.92379, 1, 0, 0.496838,-99) );
// itree = 167
fBoostWeights.push_back(0.0555615);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.517973,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.408217,-99) ,
9, -1.06698, 0, 0, 0.508917,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.521143,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.456738,-99) ,
8, -3.25036, 1, 0, 0.493768,-99) ,
7, -0.14271, 0, 0, 0.502479,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.511607,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.470869,-99) ,
0, 0.497134, 0, 0, 0.496204,-99) ,
NN(
0,
0,
-1, 2.45877, 1, -1, 0.444644,-99) ,
8, 1.12289, 0, 0, 0.474469,-99) ,
9, 2.0312, 1, 0, 0.498773,-99) );
// itree = 168
fBoostWeights.push_back(0.0259239);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.55521,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.511041,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.448995,-99) ,
7, -0.935322, 1, 0, 0.481196,-99) ,
6, -951.286, 1, 0, 0.510048,-99) ,
NN(
0,
0,
-1, -1.57122, 0, -1, 0.490893,-99) ,
8, -4.03342, 1, 0, 0.493282,-99) );
// itree = 169
fBoostWeights.push_back(0.0191129);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.503346,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.456622,-99) ,
4, 0.999819, 0, 0, 0.499806,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.458364,-99) ,
4, 0.999048, 0, 0, 0.498359,-99) ,
NN(
0,
0,
-1, 1.80898, 0, -1, 0.467859,-99) ,
9, 2.77661, 1, 0, 0.49594,-99) );
// itree = 170
fBoostWeights.push_back(0.0216582);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.588898,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.474189,-99) ,
8, -3.09051, 1, 0, 0.532394,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.503752,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.487701,-99) ,
8, -2.58898, 0, 0, 0.496261,-99) ,
4, 0.999524, 1, 0, 0.498158,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.475671,-99) ,
3, 9.26574, 1, 0, 0.49742,-99) );
// itree = 171
fBoostWeights.push_back(0.017714);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.531052,-99) ,
NN(
0,
0,
-1, 1.83819, 1, -1, 0.493955,-99) ,
8, 0.45977, 0, 0, 0.495679,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.500911,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.449505,-99) ,
7, 1.00374, 0, 0, 0.469301,-99) ,
9, 3.05633, 1, 0, 0.493881,-99) );
// itree = 172
fBoostWeights.push_back(0.0263179);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.55016,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.539875,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.495063,-99) ,
8, -4.75474, 1, 0, 0.497169,-99) ,
8, -0.618353, 0, 0, 0.499816,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.51888,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.459904,-99) ,
6, -951.286, 1, 0, 0.495579,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.444245,-99) ,
8, 0.4222, 0, 0, 0.479861,-99) ,
9, 1.73748, 1, 0, 0.496592,-99) );
// itree = 173
fBoostWeights.push_back(0.0109314);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.0744558, 0, 1, 0.503063,-99) ,
NN(
0,
0,
-1, 0.499044, 1, -1, 0.476469,-99) ,
3, 6.65533, 1, 0, 0.501431,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.45919,-99) ,
3, 9.27109, 1, 0, 0.500103,-99) );
// itree = 174
fBoostWeights.push_back(0.0227802);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.539602,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.495254,-99) ,
8, -2.5661, 1, 0, 0.519008,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.508292,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.492353,-99) ,
2, -0.00340396, 1, 0, 0.501053,-99) ,
2, 0.0714181, 0, 0, 0.503797,-99) ,
NN(
0,
0,
-1, 1.80898, 0, -1, 0.477028,-99) ,
9, 2.77661, 1, 0, 0.501604,-99) );
// itree = 175
fBoostWeights.push_back(0.0314425);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.566472,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.483484,-99) ,
7, -0.143559, 0, 0, 0.531223,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.509601,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.488704,-99) ,
6, -951.286, 1, 0, 0.498228,-99) ,
8, -1.50473, 0, 0, 0.502583,-99) ,
NN(
0,
0,
-1, -0.0685946, 0, -1, 0.481765,-99) ,
9, 1.43732, 1, 0, 0.498532,-99) );
// itree = 176
fBoostWeights.push_back(0.022849);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.525598,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.492991,-99) ,
9, -0.0383996, 1, 0, 0.51026,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.50448,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.48571,-99) ,
2, -0.00237985, 1, 0, 0.497124,-99) ,
2, 0.0325546, 0, 0, 0.500498,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.468396,-99) ,
2, -0.212005, 0, 0, 0.499118,-99) );
// itree = 177
fBoostWeights.push_back(0.0151007);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.193116, 0, 1, 0.529526,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.505661,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.461571,-99) ,
7, 0.714639, 0, 0, 0.484292,-99) ,
9, 0.452761, 1, 0, 0.513556,-99) ,
NN(
0,
0,
-1, -2.42796, 0, -1, 0.49596,-99) ,
2, 0.0711578, 0, 0, 0.498685,-99) );
// itree = 178
fBoostWeights.push_back(0.0112405);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.49809, 0, 1, 0.539831,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.501232,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.457029,-99) ,
4, 0.999796, 0, 0, 0.499381,-99) ,
4, 0.999524, 1, 0, 0.501547,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.474386,-99) ,
3, 9.3513, 1, 0, 0.500669,-99) );
// itree = 179
fBoostWeights.push_back(0.00862059);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.552572,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.499558,-99) ,
3, 9.12912, 0, 0, 0.50125,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.473137,-99) ,
4, 0.999048, 0, 0, 0.500373,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.501929,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.451466,-99) ,
6, -951.286, 0, 0, 0.476407,-99) ,
0, 0.504757, 1, 0, 0.498856,-99) );
// itree = 180
fBoostWeights.push_back(0.0112223);
fForest.push_back(
NN(
NN(
0,
0,
-1, 8.84402, 0, 1, 0.504646,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.465584,-99) ,
4, 0.999048, 0, 0, 0.50338,-99) );
// itree = 181
fBoostWeights.push_back(0.0268838);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.546723,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.496954,-99) ,
9, 1.07016, 1, 0, 0.508239,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.519744,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.489158,-99) ,
2, 0.0693356, 0, 0, 0.493677,-99) ,
8, -1.57166, 0, 0, 0.49831,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.454934,-99) ,
4, 0.999048, 0, 0, 0.496942,-99) );
// itree = 182
fBoostWeights.push_back(0.00833715);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.527381,-99) ,
NN(
0,
0,
-1, 0.999048, 0, -1, 0.498521,-99) ,
8, -4.21395, 1, 0, 0.500342,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.465395,-99) ,
9, -2.52271, 0, 0, 0.499171,-99) );
// itree = 183
fBoostWeights.push_back(0.0136529);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.335946, 0, 1, 0.503903,-99) ,
NN(
0,
0,
-1, 2.03691, 0, -1, 0.477106,-99) ,
9, 2.87901, 1, 0, 0.501831,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.448741,-99) ,
4, 0.999048, 0, 0, 0.500148,-99) );
// itree = 184
fBoostWeights.push_back(0.0140211);
fForest.push_back(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.532427,-99) ,
NN(
0,
0,
-1, 0.999048, 0, -1, 0.494495,-99) ,
8, 1.83089, 0, 0, 0.496616,-99) );
// itree = 185
fBoostWeights.push_back(0.0184608);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.428139, 0, 1, 0.506569,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.51837,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.461939,-99) ,
7, 1.00118, 0, 0, 0.484443,-99) ,
9, 2.94808, 1, 0, 0.504891,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.473151,-99) ,
9, -2.33914, 0, 0, 0.503402,-99) );
// itree = 186
fBoostWeights.push_back(0.00874322);
fForest.push_back(
NN(
NN(
0,
0,
-1, -2.34001, 0, 1, 0.522093,-99) ,
NN(
0,
0,
-1, -0.214257, 0, -1, 0.497154,-99) ,
8, -4.34575, 1, 0, 0.49913,-99) );
// itree = 187
fBoostWeights.push_back(0.0275072);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.544107,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.48961,-99) ,
6, -951.286, 0, 0, 0.514569,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.505549,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.474955,-99) ,
8, -3.5976, 0, 0, 0.501345,-99) ,
7, -0.714154, 1, 0, 0.504341,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.517648,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.476248,-99) ,
3, 1.90529, 0, 0, 0.497279,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.452764,-99) ,
3, 4.29126, 1, 0, 0.485142,-99) ,
0, 0.503804, 1, 0, 0.502463,-99) );
// itree = 188
fBoostWeights.push_back(0.0105312);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.999524, 1, 1, 0.502528,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.463684,-99) ,
2, 0.214323, 1, 0, 0.501198,-99) ,
NN(
0,
0,
-1, 0.505709, 1, -1, 0.471741,-99) ,
0, 0.504757, 1, 0, 0.499303,-99) );
// itree = 189
fBoostWeights.push_back(0.0270311);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.540389,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.525389,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.496723,-99) ,
4, 0.999955, 1, 0, 0.501946,-99) ,
4, 0.999524, 1, 0, 0.503901,-99) ,
NN(
NN(
0,
0,
-1, 0.330831, 1, 1, 0.511464,-99) ,
NN(
0,
0,
-1, -951.286, 1, -1, 0.440502,-99) ,
8, -2.43534, 0, 0, 0.493073,-99) ,
7, 0.714363, 1, 0, 0.500618,-99) );
// itree = 190
fBoostWeights.push_back(0.0185201);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.655379, 1, 1, 0.547705,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.501065,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.467409,-99) ,
7, 1.34279, 1, 0, 0.498208,-99) ,
8, -1.56139, 0, 0, 0.502053,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.503761,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.451245,-99) ,
0, 0.502851, 1, 0, 0.496336,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.459929,-99) ,
2, -0.0712726, 0, 0, 0.49019,-99) ,
9, 0.969131, 1, 0, 0.498942,-99) );
// itree = 191
fBoostWeights.push_back(0.0184225);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.547819,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.494883,-99) ,
0, 0.499044, 1, 0, 0.526161,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.520592,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.497625,-99) ,
9, -1.20757, 1, 0, 0.501225,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.447101,-99) ,
9, -2.02388, 0, 0, 0.498339,-99) ,
7, -1.57141, 1, 0, 0.500112,-99) );
// itree = 192
fBoostWeights.push_back(0.00859923);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.529449,-99) ,
NN(
0,
0,
-1, 0.999796, 0, -1, 0.498069,-99) ,
4, 0.999524, 1, 0, 0.499709,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.470306,-99) ,
3, 9.06192, 1, 0, 0.49867,-99) );
// itree = 193
fBoostWeights.push_back(0.0561787);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -0.217469, 1, 1, 0.603894,-99) ,
NN(
0,
0,
-1, 0.00112532, 0, -1, 0.488197,-99) ,
5, 0.00787725, 0, 0, 0.50414,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.336333,-99) ,
5, 0.0236326, 1, 0, 0.499839,-99) );
// itree = 194
fBoostWeights.push_back(0.020994);
fForest.push_back(
NN(
NN(
0,
0,
-1, 4.18782, 1, 1, 0.530845,-99) ,
NN(
NN(
0,
0,
-1, -1.18482, 0, 1, 0.507782,-99) ,
NN(
0,
0,
-1, 2.52607, 1, -1, 0.477701,-99) ,
9, 1.87122, 1, 0, 0.505036,-99) ,
8, 1.54117, 0, 0, 0.506684,-99) );
// itree = 195
fBoostWeights.push_back(0.019965);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.512466,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.499271,-99) ,
9, 0.514093, 1, 0, 0.507652,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.453458,-99) ,
7, -1.57141, 0, 0, 0.505655,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.483706,-99) ,
9, -2.21706, 0, 0, 0.504395,-99) );
// itree = 196
fBoostWeights.push_back(0.0261709);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 1.28571, 0, 1, 0.508296,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.444185,-99) ,
4, 0.999751, 0, 0, 0.506341,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.543012,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.397157,-99) ,
9, -0.740417, 1, 0, 0.47249,-99) ,
4, 0.999524, 0, 0, 0.504525,-99) );
// itree = 197
fBoostWeights.push_back(0.015352);
fForest.push_back(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.541653,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.500922,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.459693,-99) ,
9, 3.37852, 1, 0, 0.498566,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.401907,-99) ,
9, -2.33696, 0, 0, 0.495413,-99) ,
7, -1.85694, 1, 0, 0.497251,-99) );
// itree = 198
fBoostWeights.push_back(0.0103492);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.553313,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.530172,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.498521,-99) ,
7, 2.14287, 0, 0, 0.499854,-99) ,
4, 0.999048, 1, 0, 0.501537,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.46705,-99) ,
3, 9.38081, 1, 0, 0.500461,-99) );
// itree = 199
fBoostWeights.push_back(0.0156958);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.561847,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.496142,-99) ,
9, 3.99997, 1, 0, 0.524761,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.503028,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.474496,-99) ,
9, -2.38821, 0, 0, 0.501628,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.518964,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.445519,-99) ,
6, -951.286, 0, 0, 0.48247,-99) ,
7, 1.85714, 1, 0, 0.500324,-99) ,
8, 1.44563, 0, 0, 0.50194,-99) );
// itree = 200
fBoostWeights.push_back(0.0579567);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.0101417, 0, 1, 0.597606,-99) ,
NN(
0,
0,
-1, 0.00112677, 0, -1, 0.485965,-99) ,
5, 0.00788752, 0, 0, 0.501675,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.350295,-99) ,
5, 0.0236633, 1, 0, 0.497826,-99) );
// itree = 201
fBoostWeights.push_back(0.0131726);
fForest.push_back(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.527521,-99) ,
NN(
NN(
0,
0,
-1, -4.64854, 1, 1, 0.504051,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.466525,-99) ,
9, 2.50646, 1, 0, 0.502407,-99) ,
8, 1.75153, 0, 0, 0.503818,-99) );
// itree = 202
fBoostWeights.push_back(0.0158659);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.533694,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.502178,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.469909,-99) ,
7, -1.57142, 0, 0, 0.500641,-99) ,
8, -4.56677, 1, 0, 0.502593,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.512131,-99) ,
NN(
0,
0,
-1, 0.948828, 0, -1, 0.457186,-99) ,
8, 2.07895, 0, 0, 0.481305,-99) ,
9, 2.30105, 1, 0, 0.500255,-99) );
// itree = 203
fBoostWeights.push_back(0.0124696);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.545542,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.496108,-99) ,
7, -1.14819, 1, 0, 0.523537,-99) ,
NN(
0,
0,
-1, -1.57141, 0, -1, 0.495546,-99) ,
8, -4.34575, 1, 0, 0.497756,-99) );
// itree = 204
fBoostWeights.push_back(0.0199287);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.826485, 1, 1, 0.512103,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.503288,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.456502,-99) ,
7, 1.2133, 1, 0, 0.498445,-99) ,
8, -1.76919, 0, 0, 0.503178,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.466806,-99) ,
2, 0.213452, 1, 0, 0.501821,-99) );
// itree = 205
fBoostWeights.push_back(0.00948452);
fForest.push_back(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.535013,-99) ,
NN(
NN(
0,
0,
-1, 0.489932, 0, 1, 0.502262,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.451067,-99) ,
9, 3.15646, 1, 0, 0.500804,-99) ,
8, 2.77752, 0, 0, 0.502056,-99) );
// itree = 206
fBoostWeights.push_back(0.010389);
fForest.push_back(
NN(
NN(
0,
0,
-1, 0.143729, 1, 1, 0.525253,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.533191,-99) ,
NN(
0,
0,
-1, -1.96496, 0, -1, 0.498082,-99) ,
8, -4.56311, 1, 0, 0.500086,-99) ,
8, 1.33504, 0, 0, 0.501827,-99) );
// itree = 207
fBoostWeights.push_back(0.0185284);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.55372,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.492132,-99) ,
7, -1.21292, 1, 0, 0.521679,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.511096,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.495678,-99) ,
2, -0.0304183, 1, 0, 0.500057,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.467853,-99) ,
2, 0.21442, 1, 0, 0.498898,-99) ,
8, -4.25254, 1, 0, 0.500992,-99) );
// itree = 208
fBoostWeights.push_back(0.0200099);
fForest.push_back(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.534805,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.52444,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.497642,-99) ,
3, 4.27915, 1, 0, 0.514908,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.520433,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.494104,-99) ,
8, 0.509202, 0, 0, 0.496973,-99) ,
2, 0.0509893, 0, 0, 0.499873,-99) ,
2, 0.214255, 0, 0, 0.501294,-99) );
// itree = 209
fBoostWeights.push_back(0.0284922);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.562014,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.487833,-99) ,
0, 0.499043, 1, 0, 0.531968,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.507432,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.481309,-99) ,
7, -0.700446, 0, 0, 0.504272,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.526513,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.397746,-99) ,
7, -0.967779, 1, 0, 0.474911,-99) ,
9, -1.85949, 0, 0, 0.502097,-99) ,
7, -1.57122, 1, 0, 0.50401,-99) );
// itree = 210
fBoostWeights.push_back(0.0225442);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.542305,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.504007,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.466815,-99) ,
9, -1.85282, 0, 0, 0.501148,-99) ,
7, -1.57125, 1, 0, 0.50377,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.53067,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.490646,-99) ,
2, 0.0881446, 0, 0, 0.495127,-99) ,
NN(
0,
0,
-1, -951.286, 0, -1, 0.465738,-99) ,
3, 4.52382, 1, 0, 0.488418,-99) ,
0, 0.499995, 1, 0, 0.498754,-99) );
// itree = 211
fBoostWeights.push_back(0.0495702);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -0.922157, 1, 1, 0.574882,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.500572,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.455292,-99) ,
5, 0.000956231, 0, 0, 0.491204,-99) ,
5, 0.00669368, 0, 0, 0.506629,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.357317,-99) ,
5, 0.0234313, 1, 0, 0.50287,-99) );
// itree = 212
fBoostWeights.push_back(0.016827);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.549773,-99) ,
NN(
0,
0,
-1, 2.14285, 1, -1, 0.495165,-99) ,
8, 0.462242, 0, 0, 0.497806,-99) ,
NN(
0,
0,
-1, 2.38939, 0, -1, 0.471703,-99) ,
9, 3.05633, 1, 0, 0.496083,-99) );
// itree = 213
fBoostWeights.push_back(0.025077);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.550346,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.529254,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.491878,-99) ,
7, 2.14288, 0, 0, 0.493414,-99) ,
3, 8.84402, 0, 0, 0.495497,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.514648,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.415345,-99) ,
8, -3.02063, 1, 0, 0.467347,-99) ,
4, 0.999524, 0, 0, 0.493971,-99) );
// itree = 214
fBoostWeights.push_back(0.0217035);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.556558,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.497216,-99) ,
7, 0.141961, 1, 0, 0.522208,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.522148,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.498152,-99) ,
8, -1.34185, 0, 0, 0.501592,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.5514,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.438761,-99) ,
6, -951.286, 0, 0, 0.474185,-99) ,
9, 1.80356, 1, 0, 0.499021,-99) ,
8, 1.40603, 0, 0, 0.500627,-99) );
// itree = 215
fBoostWeights.push_back(0.0154282);
fForest.push_back(
NN(
NN(
0,
0,
-1, -2.38558, 0, 1, 0.52945,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.500317,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.457824,-99) ,
7, 2.14286, 1, 0, 0.498723,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.518803,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.460131,-99) ,
7, -0.139793, 1, 0, 0.473932,-99) ,
9, 2.22293, 1, 0, 0.495633,-99) ,
8, -4.3753, 1, 0, 0.498099,-99) );
// itree = 216
fBoostWeights.push_back(0.0187342);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.555424,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.467139,-99) ,
6, -951.286, 1, 0, 0.518887,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.502344,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.47662,-99) ,
9, 1.41634, 1, 0, 0.499399,-99) ,
8, 0.807362, 0, 0, 0.50118,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.458226,-99) ,
0, 0.489519, 0, 0, 0.500096,-99) );
// itree = 217
fBoostWeights.push_back(0.0243633);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.565021,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.516282,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.480145,-99) ,
7, 1.00182, 0, 0, 0.494082,-99) ,
9, 2.83231, 1, 0, 0.518785,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.525715,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.497695,-99) ,
8, -2.03891, 0, 0, 0.501264,-99) ,
NN(
0,
0,
-1, -951.286, 0, -1, 0.476568,-99) ,
9, 0.701251, 1, 0, 0.495992,-99) ,
8, 0.375626, 0, 0, 0.498687,-99) );
// itree = 218
fBoostWeights.push_back(0.028292);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.516549,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.493092,-99) ,
4, 0.999989, 0, 0, 0.507053,-99) ,
NN(
0,
0,
-1, 0.999566, 1, -1, 0.470526,-99) ,
4, 0.999773, 0, 0, 0.504891,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.470883,-99) ,
4, 0.999048, 0, 0, 0.503791,-99) );
// itree = 219
fBoostWeights.push_back(0.00963252);
fForest.push_back(
NN(
NN(
0,
0,
-1, 2.14288, 0, 1, 0.503741,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.462904,-99) ,
4, 0.999048, 0, 0, 0.502426,-99) );
// itree = 220
fBoostWeights.push_back(0.0094948);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.558829,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.500122,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.468183,-99) ,
9, 2.03758, 1, 0, 0.49855,-99) ,
8, 0.86527, 0, 0, 0.500515,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.475805,-99) ,
9, 3.27805, 1, 0, 0.499078,-99) );
// itree = 221
fBoostWeights.push_back(0.0212796);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.561259,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.507757,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.467809,-99) ,
9, -2.03771, 0, 0, 0.487386,-99) ,
6, -951.286, 1, 0, 0.516738,-99) ,
NN(
NN(
0,
0,
-1, 2.83009, 1, -1, 0.496545,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.504664,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.448291,-99) ,
9, 0.0187005, 0, 0, 0.473103,-99) ,
7, -0.999854, 0, 0, 0.494152,-99) ,
8, -3.9435, 1, 0, 0.497416,-99) );
// itree = 222
fBoostWeights.push_back(0.0091562);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.54253,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.500867,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.467173,-99) ,
4, 0.999683, 0, 0, 0.499562,-99) ,
4, 0.999049, 1, 0, 0.500903,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.4615,-99) ,
3, 9.10638, 1, 0, 0.499544,-99) );
// itree = 223
fBoostWeights.push_back(0.0166481);
fForest.push_back(
NN(
NN(
0,
0,
-1, -4.71385, 1, 1, 0.525618,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.502584,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.484943,-99) ,
3, 4.7423, 1, 0, 0.499254,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.447944,-99) ,
7, -1.57124, 0, 0, 0.497171,-99) ,
8, -4.34575, 1, 0, 0.499403,-99) );
// itree = 224
fBoostWeights.push_back(0.0149346);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -3.10161, 1, 1, 0.538123,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.527477,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.496421,-99) ,
7, 1.85712, 0, 0, 0.498526,-99) ,
4, 0.999524, 1, 0, 0.500617,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.475876,-99) ,
3, 9.39171, 1, 0, 0.499854,-99) );
// itree = 225
fBoostWeights.push_back(0.0117752);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.582281,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.496461,-99) ,
8, -3.07698, 1, 0, 0.540477,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.543262,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.498812,-99) ,
7, 2.14285, 0, 0, 0.500683,-99) ,
4, 0.999524, 1, 0, 0.502827,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.475513,-99) ,
3, 8.95698, 1, 0, 0.501808,-99) );
// itree = 226
fBoostWeights.push_back(0.0278537);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.558421,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.506486,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.475748,-99) ,
7, 1.14845, 1, 0, 0.503448,-99) ,
4, 0.999048, 1, 0, 0.505902,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.521034,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.486802,-99) ,
7, 0.714564, 0, 0, 0.5017,-99) ,
NN(
0,
0,
-1, -951.286, 1, -1, 0.453503,-99) ,
8, -1.27878, 0, 0, 0.493188,-99) ,
9, 0.71673, 1, 0, 0.502066,-99) );
// itree = 227
fBoostWeights.push_back(0.014663);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.540789,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.508905,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.496128,-99) ,
4, 0.999955, 1, 0, 0.498777,-99) ,
7, 2.14288, 0, 0, 0.500642,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.467942,-99) ,
4, 0.999048, 0, 0, 0.499589,-99) );
// itree = 228
fBoostWeights.push_back(0.0189868);
fForest.push_back(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.534586,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.541855,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.505242,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.492194,-99) ,
6, -951.286, 0, 0, 0.498617,-99) ,
8, -4.65576, 1, 0, 0.500694,-99) ,
8, 2.18219, 0, 0, 0.502305,-99) );
// itree = 229
fBoostWeights.push_back(0.06286);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.587488,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.535426,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.489078,-99) ,
8, -3.37597, 1, 0, 0.499725,-99) ,
8, 1.94056, 0, 0, 0.504398,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.523499,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.450084,-99) ,
6, -0.918336, 0, 0, 0.508795,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.211575,-99) ,
6, -2.14283, 0, 0, 0.492772,-99) ,
6, -951.286, 1, 0, 0.498672,-99) );
// itree = 230
fBoostWeights.push_back(0.0317315);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -0.437416, 0, 1, 0.554722,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.515275,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.476311,-99) ,
9, 2.84463, 1, 0, 0.504722,-99) ,
9, 0.798978, 1, 0, 0.513981,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.531474,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.515419,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.491093,-99) ,
2, -0.0725759, 1, 0, 0.49509,-99) ,
8, -4.71383, 1, 0, 0.497342,-99) ,
8, -1.76919, 0, 0, 0.503111,-99) );
// itree = 231
fBoostWeights.push_back(0.0157722);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.537922,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.4887,-99) ,
6, -951.286, 1, 0, 0.517807,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.502983,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.46421,-99) ,
7, 2.1428, 1, 0, 0.5014,-99) ,
8, 0.552358, 0, 0, 0.503189,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.458249,-99) ,
9, -2.56061, 0, 0, 0.501794,-99) );
// itree = 232
fBoostWeights.push_back(0.0380726);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.529935,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.517916,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.49685,-99) ,
0, 0.50317, 1, 0, 0.508025,-99) ,
2, 0.0705203, 0, 0, 0.51199,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.509992,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.435695,-99) ,
7, -1.57124, 0, 0, 0.504805,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.510594,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.280206,-99) ,
6, -1.85716, 0, 0, 0.491855,-99) ,
6, -951.286, 1, 0, 0.498354,-99) ,
0, 0.500947, 0, 0, 0.501936,-99) );
// itree = 233
fBoostWeights.push_back(0.0329805);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.534373,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.46214,-99) ,
4, 0.999955, 0, 0, 0.516571,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.505113,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.486428,-99) ,
4, 0.999955, 1, 0, 0.490218,-99) ,
7, 1.28577, 0, 0, 0.494348,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.454472,-99) ,
4, 0.999048, 0, 0, 0.493065,-99) );
// itree = 234
fBoostWeights.push_back(0.0402412);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.537261,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.480632,-99) ,
8, -3.28861, 1, 0, 0.507032,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.509705,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.478452,-99) ,
6, -951.286, 1, 0, 0.493874,-99) ,
7, -0.428443, 1, 0, 0.497516,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.455507,-99) ,
9, -2.39957, 0, 0, 0.495729,-99) );
// itree = 235
fBoostWeights.push_back(0.0211715);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.527106,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.49845,-99) ,
9, 1.43732, 1, 0, 0.520937,-99) ,
NN(
0,
0,
-1, 0.503169, 1, -1, 0.481721,-99) ,
3, 4.38966, 1, 0, 0.51149,-99) ,
NN(
NN(
0,
0,
-1, -1.60824, 1, 1, 0.521704,-99) ,
NN(
0,
0,
-1, -1.59097, 0, -1, 0.494715,-99) ,
7, -1.28555, 1, 0, 0.497478,-99) ,
0, 0.500947, 0, 0, 0.501142,-99) );
// itree = 236
fBoostWeights.push_back(0.0134379);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.502994,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.46191,-99) ,
7, 2.34693, 1, 0, 0.501755,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.455253,-99) ,
7, -1.57141, 0, 0, 0.50001,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.472736,-99) ,
9, -2.26819, 0, 0, 0.498578,-99) );
// itree = 237
fBoostWeights.push_back(0.0122734);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 8.78248, 0, 1, 0.503157,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.509949,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.458407,-99) ,
4, 0.999562, 1, 0, 0.477728,-99) ,
4, 0.999819, 0, 0, 0.501257,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.463469,-99) ,
4, 0.999048, 0, 0, 0.500061,-99) );
// itree = 238
fBoostWeights.push_back(0.0285441);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.516491,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.441567,-99) ,
4, 0.999955, 0, 0, 0.508183,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.517109,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.490602,-99) ,
2, 0.0706818, 0, 0, 0.494463,-99) ,
8, -1.41741, 0, 0, 0.498491,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.466479,-99) ,
4, 0.999048, 0, 0, 0.497478,-99) );
// itree = 239
fBoostWeights.push_back(0.0208496);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.536315,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.499928,-99) ,
0, 0.495233, 0, 0, 0.524413,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.500786,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.463883,-99) ,
9, -1.57029, 0, 0, 0.496786,-99) ,
7, -1.28553, 1, 0, 0.499645,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.517298,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.484037,-99) ,
2, -0.0733765, 1, 0, 0.490849,-99) ,
NN(
0,
0,
-1, -0.423445, 0, -1, 0.467963,-99) ,
9, 0.66396, 1, 0, 0.483316,-99) ,
0, 0.500947, 1, 0, 0.495493,-99) );
// itree = 240
fBoostWeights.push_back(0.0200758);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.505547,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.491946,-99) ,
7, -0.714145, 1, 0, 0.49499,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.468909,-99) ,
2, -0.132887, 0, 0, 0.493723,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.458038,-99) ,
2, -0.214506, 0, 0, 0.492227,-99) );
// itree = 241
fBoostWeights.push_back(0.0221702);
fForest.push_back(
NN(
NN(
0,
0,
-1, -1.14077, 1, 1, 0.522415,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.500914,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.474012,-99) ,
7, -0.714276, 0, 0, 0.497382,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.526215,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.353113,-99) ,
7, -0.659784, 1, 0, 0.464641,-99) ,
9, -1.51118, 0, 0, 0.494407,-99) ,
8, -4.34575, 1, 0, 0.496632,-99) );
// itree = 242
fBoostWeights.push_back(0.024522);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.505977,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.48329,-99) ,
4, 0.999989, 0, 0, 0.496785,-99) ,
NN(
0,
0,
-1, 0.999566, 1, -1, 0.472589,-99) ,
4, 0.999773, 0, 0, 0.495328,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.460257,-99) ,
4, 0.999048, 0, 0, 0.494212,-99) );
// itree = 243
fBoostWeights.push_back(0.014065);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.502888,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.446375,-99) ,
7, -1.77532, 0, 0, 0.501303,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.463043,-99) ,
7, 2.14288, 1, 0, 0.499712,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.458847,-99) ,
9, -2.42796, 0, 0, 0.498142,-99) );
// itree = 244
fBoostWeights.push_back(0.01817);
fForest.push_back(
NN(
NN(
0,
0,
-1, 0.42926, 0, 1, 0.514913,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.519957,-99) ,
NN(
0,
0,
-1, -0.133106, 0, -1, 0.491843,-99) ,
2, -0.214704, 1, 0, 0.493009,-99) ,
0, 0.491424, 1, 0, 0.49454,-99) );
// itree = 245
fBoostWeights.push_back(0.0153854);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.540602,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.494783,-99) ,
7, -2.04743, 0, 0, 0.522182,-99) ,
NN(
NN(
0,
0,
-1, 3.51503, 1, -1, 0.498021,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.51863,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.366108,-99) ,
7, -0.912773, 1, 0, 0.465412,-99) ,
9, -1.83904, 0, 0, 0.495475,-99) ,
7, -1.57124, 1, 0, 0.497178,-99) );
// itree = 246
fBoostWeights.push_back(0.0221791);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.507637,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.467942,-99) ,
7, -1.57142, 0, 0, 0.505869,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.505531,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.445327,-99) ,
8, 1.36917, 0, 0, 0.486646,-99) ,
9, 2.51767, 1, 0, 0.503968,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.455211,-99) ,
9, -2.52271, 0, 0, 0.502353,-99) );
// itree = 247
fBoostWeights.push_back(0.023954);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.540689,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.484913,-99) ,
7, -1.97941, 0, 0, 0.515311,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.501565,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.422715,-99) ,
7, 1.9116, 1, 0, 0.496456,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.500253,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.231473,-99) ,
6, -2.14272, 0, 0, 0.485303,-99) ,
6, -951.286, 1, 0, 0.490853,-99) ,
7, -1.57126, 1, 0, 0.492372,-99) );
// itree = 248
fBoostWeights.push_back(0.0194437);
fForest.push_back(
NN(
NN(
0,
0,
-1, -2.04743, 0, 1, 0.521602,-99) ,
NN(
0,
0,
-1, -1.92276, 0, -1, 0.491072,-99) ,
7, -1.57124, 1, 0, 0.492981,-99) );
// itree = 249
fBoostWeights.push_back(0.0199536);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.52642,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.484051,-99) ,
8, -1.92738, 0, 0, 0.51274,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.542183,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.496789,-99) ,
4, 0.999524, 1, 0, 0.498953,-99) ,
7, 1.28579, 0, 0, 0.501141,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.502907,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.459459,-99) ,
3, 2.65193, 1, 0, 0.490619,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.439423,-99) ,
3, 4.54098, 1, 0, 0.479848,-99) ,
0, 0.493329, 0, 0, 0.498323,-99) );
// itree = 250
fBoostWeights.push_back(0.0207314);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.511649,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.495603,-99) ,
8, -2.93167, 0, 0, 0.504495,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.502095,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.444556,-99) ,
3, 4.08044, 1, 0, 0.488944,-99) ,
9, 1.62458, 1, 0, 0.501717,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.464246,-99) ,
9, -2.50949, 0, 0, 0.500435,-99) );
// itree = 251
fBoostWeights.push_back(0.0258973);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.55792,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.510156,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.49002,-99) ,
3, 0.980622, 1, 0, 0.494229,-99) ,
3, 9.13153, 0, 0, 0.496277,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.462354,-99) ,
4, 0.999524, 0, 0, 0.494472,-99) );
// itree = 252
fBoostWeights.push_back(0.0166115);
fForest.push_back(
NN(
NN(
0,
0,
-1, -2.04744, 0, 1, 0.520325,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.501737,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.490342,-99) ,
9, 0.370383, 1, 0, 0.49714,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.445706,-99) ,
9, -2.02983, 0, 0, 0.494464,-99) ,
7, -1.57126, 1, 0, 0.496087,-99) );
// itree = 253
fBoostWeights.push_back(0.00966553);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 8.2201, 0, 1, 0.501713,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.444572,-99) ,
4, 0.999751, 0, 0, 0.499944,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.504748,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.440525,-99) ,
7, 0.429869, 1, 0, 0.475128,-99) ,
4, 0.999524, 0, 0, 0.498586,-99) );
// itree = 254
fBoostWeights.push_back(0.0153655);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.54773,-99) ,
NN(
0,
0,
-1, 0.999683, 0, -1, 0.495485,-99) ,
7, 2.14283, 0, 0, 0.497747,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.451533,-99) ,
4, 0.999048, 0, 0, 0.496324,-99) );
// itree = 255
fBoostWeights.push_back(0.0267424);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.554901,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.525497,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.492086,-99) ,
8, -2.10557, 0, 0, 0.497204,-99) ,
4, 0.999048, 1, 0, 0.499776,-99) ,
NN(
0,
0,
-1, -0.0716622, 0, -1, 0.484816,-99) ,
9, 0.71673, 1, 0, 0.495255,-99) );
// itree = 256
fBoostWeights.push_back(0.0199212);
fForest.push_back(
NN(
NN(
0,
0,
-1, -4.73928, 1, 1, 0.524001,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.516937,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.491223,-99) ,
3, 4.48129, 1, 0, 0.510865,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.508178,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.493895,-99) ,
8, -1.09299, 0, 0, 0.497623,-99) ,
0, 0.500947, 0, 0, 0.501085,-99) ,
8, -4.3753, 1, 0, 0.502787,-99) );
// itree = 257
fBoostWeights.push_back(0.0166276);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.565628,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.544855,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.495801,-99) ,
7, 1.20341, 0, 0, 0.510761,-99) ,
7, -0.428761, 1, 0, 0.524445,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.501799,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.48943,-99) ,
9, -1.3985, 0, 0, 0.499144,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.448016,-99) ,
7, 2.14281, 1, 0, 0.497196,-99) ,
8, 0.375626, 0, 0, 0.500461,-99) );
// itree = 258
fBoostWeights.push_back(0.014685);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.553479,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.493095,-99) ,
9, 2.95895, 1, 0, 0.525761,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.502633,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.443951,-99) ,
9, 1.99394, 1, 0, 0.500684,-99) ,
8, 0.434181, 0, 0, 0.502708,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.472983,-99) ,
9, 4.15532, 1, 0, 0.501686,-99) );
// itree = 259
fBoostWeights.push_back(0.0169789);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.428384, 1, 1, 0.551161,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.478666,-99) ,
6, -951.286, 1, 0, 0.521323,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.501429,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.48447,-99) ,
7, 1.28571, 1, 0, 0.499089,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.427685,-99) ,
9, 2.26027, 1, 0, 0.497024,-99) ,
8, 0.807362, 0, 0, 0.499287,-99) );
// itree = 260
fBoostWeights.push_back(0.026732);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.518212,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.478355,-99) ,
2, 0.240317, 1, 0, 0.513474,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.506245,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.486863,-99) ,
2, -0.016158, 1, 0, 0.495109,-99) ,
2, 0.030474, 0, 0, 0.49998,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.46508,-99) ,
2, -0.214346, 0, 0, 0.498543,-99) );
// itree = 261
fBoostWeights.push_back(0.0362808);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.564219,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.560418,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.492321,-99) ,
4, 0.999048, 1, 0, 0.495548,-99) ,
1, 0.00652116, 0, 0, 0.501161,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.52652,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.486903,-99) ,
9, 1.15811, 1, 0, 0.502064,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.509076,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.455492,-99) ,
8, 0.641453, 0, 0, 0.474951,-99) ,
7, 0.714406, 0, 0, 0.48893,-99) ,
9, 0.460091, 1, 0, 0.496891,-99) );
// itree = 262
fBoostWeights.push_back(0.0162875);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.999524, 1, 1, 0.505772,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.501437,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.465991,-99) ,
8, -2.3021, 0, 0, 0.492446,-99) ,
7, 0.999924, 1, 0, 0.502838,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.502439,-99) ,
NN(
0,
0,
-1, 0.491696, 1, -1, 0.477322,-99) ,
2, -0.0700905, 1, 0, 0.483385,-99) ,
0, 0.493329, 0, 0, 0.500211,-99) );
// itree = 263
fBoostWeights.push_back(0.0203046);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.53313,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.52526,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.496697,-99) ,
7, 1.85714, 0, 0, 0.498651,-99) ,
4, 0.999524, 1, 0, 0.500566,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.512394,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.46912,-99) ,
2, 0.0781859, 1, 0, 0.496596,-99) ,
NN(
0,
0,
-1, -951.286, 0, -1, 0.457527,-99) ,
2, -0.0713091, 0, 0, 0.485,-99) ,
3, 4.70919, 1, 0, 0.497583,-99) );
// itree = 264
fBoostWeights.push_back(0.0336569);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.558077,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.542088,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.49103,-99) ,
8, -2.6519, 0, 0, 0.498136,-99) ,
1, -0.00547265, 1, 0, 0.504153,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.507301,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.474681,-99) ,
9, 2.48182, 1, 0, 0.500973,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.501949,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.465842,-99) ,
8, 0.238222, 0, 0, 0.478487,-99) ,
7, 0.428682, 0, 0, 0.492302,-99) ,
9, -0.0810067, 1, 0, 0.498554,-99) );
// itree = 265
fBoostWeights.push_back(0.0167008);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 8.74869, 0, 1, 0.505594,-99) ,
NN(
0,
0,
-1, -0.826942, 1, -1, 0.469889,-99) ,
4, 0.999819, 0, 0, 0.503058,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.460716,-99) ,
4, 0.999048, 0, 0, 0.501713,-99) );
// itree = 266
fBoostWeights.push_back(0.0423973);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.573115,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.514163,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.422928,-99) ,
7, 0.146572, 1, 0, 0.498931,-99) ,
8, -3.01559, 0, 0, 0.508193,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.502731,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.484296,-99) ,
7, 1.0545, 1, 0, 0.494743,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.531572,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.460558,-99) ,
8, 0.724652, 0, 0, 0.47586,-99) ,
7, -0.142744, 0, 0, 0.490309,-99) ,
9, -0.625753, 1, 0, 0.497171,-99) );
// itree = 267
fBoostWeights.push_back(0.0287412);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.535297,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.470977,-99) ,
4, 0.999955, 0, 0, 0.519898,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.507064,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.48962,-99) ,
4, 0.999955, 1, 0, 0.493168,-99) ,
7, 1.2857, 0, 0, 0.497378,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.459371,-99) ,
4, 0.999048, 0, 0, 0.496162,-99) );
// itree = 268
fBoostWeights.push_back(0.0101407);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.525398,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.499488,-99) ,
4, 0.999524, 1, 0, 0.500982,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.462645,-99) ,
9, 3.50693, 1, 0, 0.4992,-99) ,
NN(
0,
0,
-1, 2.34691, 1, -1, 0.474005,-99) ,
7, 1.85712, 1, 0, 0.497539,-99) );
// itree = 269
fBoostWeights.push_back(0.0207541);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 8.78553, 0, 1, 0.506502,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.465621,-99) ,
4, 0.999796, 0, 0, 0.504735,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.523957,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.413199,-99) ,
9, -0.918901, 1, 0, 0.465125,-99) ,
4, 0.999524, 0, 0, 0.502605,-99) );
// itree = 270
fBoostWeights.push_back(0.017533);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.544605,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.493698,-99) ,
6, -951.286, 0, 0, 0.518524,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.53724,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.495808,-99) ,
4, 0.999524, 1, 0, 0.49789,-99) ,
7, 1.57147, 0, 0, 0.50012,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.467375,-99) ,
3, 9.10638, 1, 0, 0.498999,-99) );
// itree = 271
fBoostWeights.push_back(0.0221001);
fForest.push_back(
NN(
NN(
0,
0,
-1, 0.497137, 1, 1, 0.530889,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.508022,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.495708,-99) ,
9, -0.0667686, 1, 0, 0.50152,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.511698,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.383514,-99) ,
7, -0.980704, 1, 0, 0.459144,-99) ,
9, -1.85282, 0, 0, 0.498344,-99) ,
7, -1.57126, 1, 0, 0.500421,-99) );
// itree = 272
fBoostWeights.push_back(0.0271541);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.540014,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.453844,-99) ,
4, 0.999955, 0, 0, 0.520366,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.507023,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.492051,-99) ,
6, -951.286, 1, 0, 0.499712,-99) ,
7, 1.28571, 0, 0, 0.502935,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.462261,-99) ,
4, 0.999048, 0, 0, 0.501625,-99) );
// itree = 273
fBoostWeights.push_back(0.0124128);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.54024,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.525241,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.497528,-99) ,
3, 8.05765, 0, 0, 0.498909,-99) ,
7, 2.14288, 0, 0, 0.500669,-99) ,
NN(
0,
0,
-1, 0.497138, 1, -1, 0.475425,-99) ,
4, 0.999524, 0, 0, 0.499317,-99) );
// itree = 274
fBoostWeights.push_back(0.0162044);
fForest.push_back(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.531713,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.503876,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.464093,-99) ,
7, 2.30611, 1, 0, 0.502596,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.451455,-99) ,
9, -2.13785, 0, 0, 0.49995,-99) ,
7, -1.85697, 1, 0, 0.501162,-99) );
// itree = 275
fBoostWeights.push_back(0.0234429);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.511746,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.486167,-99) ,
7, -0.713913, 0, 0, 0.506078,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.527986,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.49097,-99) ,
7, -1.57124, 1, 0, 0.493308,-99) ,
0, 0.500947, 0, 0, 0.496636,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.45726,-99) ,
3, 9.27458, 1, 0, 0.495436,-99) );
// itree = 276
fBoostWeights.push_back(0.0198869);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.556527,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.493884,-99) ,
6, -951.286, 0, 0, 0.520481,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.50642,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.48523,-99) ,
9, -1.50033, 0, 0, 0.503883,-99) ,
7, -1.28571, 1, 0, 0.505572,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.47962,-99) ,
0, 0.490472, 0, 0, 0.504438,-99) );
// itree = 277
fBoostWeights.push_back(0.010327);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.548845,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.498763,-99) ,
3, 9.08707, 0, 0, 0.50038,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.464582,-99) ,
4, 0.999683, 0, 0, 0.498924,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.462379,-99) ,
4, 0.999048, 0, 0, 0.497767,-99) );
// itree = 278
fBoostWeights.push_back(0.0132751);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 8.77612, 0, 1, 0.504519,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.470174,-99) ,
4, 0.999683, 0, 0, 0.503121,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.460261,-99) ,
4, 0.999048, 0, 0, 0.501757,-99) );
// itree = 279
fBoostWeights.push_back(0.0185743);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -3.2968, 1, 1, 0.533426,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.502715,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.468986,-99) ,
4, 0.999796, 0, 0, 0.501008,-99) ,
4, 0.999524, 1, 0, 0.503313,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.507398,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.483392,-99) ,
6, -951.286, 0, 0, 0.492736,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.456745,-99) ,
2, -0.071544, 0, 0, 0.486853,-99) ,
9, 0.954811, 1, 0, 0.499026,-99) );
// itree = 280
fBoostWeights.push_back(0.0204712);
fForest.push_back(
NN(
NN(
0,
0,
-1, -2.90347, 1, 1, 0.52766,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.503465,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.472316,-99) ,
7, -0.918118, 0, 0, 0.50113,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.5198,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.379226,-99) ,
7, -0.992684, 1, 0, 0.463771,-99) ,
9, -1.89697, 0, 0, 0.498569,-99) ,
7, -1.57122, 1, 0, 0.500442,-99) );
// itree = 281
fBoostWeights.push_back(0.0197159);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.537444,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.526827,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.493917,-99) ,
7, 2.14288, 0, 0, 0.49529,-99) ,
4, 0.999524, 1, 0, 0.497571,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.454183,-99) ,
3, 9.12537, 1, 0, 0.496105,-99) );
// itree = 282
fBoostWeights.push_back(0.0269121);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.533111,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.485362,-99) ,
9, 0.417484, 1, 0, 0.515238,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.513729,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.491984,-99) ,
0, 0.502852, 0, 0, 0.495242,-99) ,
3, 0.957822, 1, 0, 0.499382,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.458624,-99) ,
3, 9.07131, 1, 0, 0.497981,-99) );
// itree = 283
fBoostWeights.push_back(0.0173821);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.554676,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.497952,-99) ,
6, -951.286, 0, 0, 0.521682,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.504018,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.475818,-99) ,
9, 2.71202, 1, 0, 0.501399,-99) ,
7, -1.28555, 1, 0, 0.503516,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.463397,-99) ,
4, 0.999048, 0, 0, 0.502261,-99) );
// itree = 284
fBoostWeights.push_back(0.0157706);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.512099,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.496899,-99) ,
0, 0.495233, 1, 0, 0.500536,-99) ,
NN(
0,
0,
-1, -2.87098, 1, -1, 0.473484,-99) ,
4, 0.999819, 0, 0, 0.49858,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.458511,-99) ,
4, 0.999048, 0, 0, 0.497318,-99) );
// itree = 285
fBoostWeights.push_back(0.00685288);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 8.75156, 0, 1, 0.501572,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.47321,-99) ,
4, 0.999683, 0, 0, 0.500406,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.471752,-99) ,
4, 0.999048, 0, 0, 0.499492,-99) );
// itree = 286
fBoostWeights.push_back(0.0426274);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.57111,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.490445,-99) ,
9, -2.1034, 0, 0, 0.530544,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.52529,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.457804,-99) ,
6, -951.286, 0, 0, 0.483265,-99) ,
9, -1.56188, 1, 0, 0.504219,-99) ,
NN(
NN(
0,
0,
-1, 0.999524, 0, -1, 0.496299,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.551441,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.419585,-99) ,
9, -1.05446, 0, 0, 0.467046,-99) ,
8, -3.38792, 0, 0, 0.491761,-99) ,
7, -0.428573, 1, 0, 0.495599,-99) );
// itree = 287
fBoostWeights.push_back(0.0226117);
fForest.push_back(
NN(
NN(
0,
0,
-1, -2.04746, 0, 1, 0.53093,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.505553,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.470998,-99) ,
4, 0.999048, 0, 0, 0.504526,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.532745,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.416885,-99) ,
7, -0.962426, 1, 0, 0.48598,-99) ,
9, -1.84583, 0, 0, 0.503061,-99) ,
7, -1.57128, 1, 0, 0.50486,-99) );
// itree = 288
fBoostWeights.push_back(0.0369081);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.527799,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.494031,-99) ,
9, -2.0503, 0, 0, 0.517715,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.540965,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.469477,-99) ,
6, -951.286, 0, 0, 0.494799,-99) ,
9, -0.701084, 1, 0, 0.509148,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.501498,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.433977,-99) ,
4, 0.999524, 0, 0, 0.49798,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.533777,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.344456,-99) ,
9, -1.11732, 0, 0, 0.453435,-99) ,
8, -3.43984, 0, 0, 0.493336,-99) ,
7, -0.142851, 1, 0, 0.499712,-99) );
// itree = 289
fBoostWeights.push_back(0.0205797);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.532894,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.509888,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.476671,-99) ,
3, 1.71359, 0, 0, 0.496082,-99) ,
9, 2.80003, 1, 0, 0.508682,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.52017,-99) ,
NN(
0,
0,
-1, -1.57141, 0, -1, 0.492056,-99) ,
8, -4.5149, 1, 0, 0.493904,-99) ,
8, 0.299902, 0, 0, 0.495698,-99) );
// itree = 290
fBoostWeights.push_back(0.0154364);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 1.28567, 0, 1, 0.518329,-99) ,
NN(
0,
0,
-1, 2.14288, 1, -1, 0.495595,-99) ,
8, 0.0767756, 0, 0, 0.498678,-99) ,
NN(
0,
0,
-1, 0.506117, 0, -1, 0.471432,-99) ,
0, 0.504757, 1, 0, 0.496937,-99) );
// itree = 291
fBoostWeights.push_back(0.0399748);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -2.05895, 0, 1, 0.535083,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.511059,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.440259,-99) ,
2, 0.0556562, 1, 0, 0.498302,-99) ,
9, -1.49815, 1, 0, 0.515351,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.524546,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.49706,-99) ,
7, 0.224466, 1, 0, 0.504231,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.536111,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.418846,-99) ,
9, -1.07522, 0, 0, 0.462577,-99) ,
8, -3.40863, 0, 0, 0.498021,-99) ,
7, -0.428588, 1, 0, 0.503362,-99) );
// itree = 292
fBoostWeights.push_back(0.0187682);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -951.286, 0, 1, 0.528708,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.511436,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.479777,-99) ,
8, 1.2669, 0, 0, 0.495757,-99) ,
9, 1.91995, 1, 0, 0.509102,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.532626,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.497424,-99) ,
8, -4.38143, 1, 0, 0.499492,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.465921,-99) ,
9, -2.5137, 0, 0, 0.498015,-99) ,
8, -1.06408, 0, 0, 0.500707,-99) );
// itree = 293
fBoostWeights.push_back(0.0166875);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.541864,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.504183,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.474691,-99) ,
9, -1.98722, 0, 0, 0.502575,-99) ,
8, -4.78669, 1, 0, 0.504061,-99) ,
NN(
0,
0,
-1, 0.716187, 0, -1, 0.465791,-99) ,
9, 3.22526, 1, 0, 0.501798,-99) );
// itree = 294
fBoostWeights.push_back(0.0211158);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.547181,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.553372,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.499323,-99) ,
4, 0.999048, 1, 0, 0.501767,-99) ,
8, -1.95805, 0, 0, 0.504969,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.524472,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.484023,-99) ,
6, -951.286, 0, 0, 0.502239,-99) ,
NN(
0,
0,
-1, 4.43439, 1, -1, 0.481993,-99) ,
7, 1.00011, 0, 0, 0.490648,-99) ,
9, 0.460091, 1, 0, 0.499985,-99) );
// itree = 295
fBoostWeights.push_back(0.0191525);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.143715, 0, 1, 0.517574,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.506236,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.492427,-99) ,
8, -2.3696, 0, 0, 0.498465,-99) ,
2, 0.071135, 0, 0, 0.501432,-99) ,
NN(
0,
0,
-1, 0.733414, 0, -1, 0.475499,-99) ,
9, 3.24397, 1, 0, 0.49989,-99) );
// itree = 296
fBoostWeights.push_back(0.0144911);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.56113,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.506393,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.476679,-99) ,
7, -0.935322, 1, 0, 0.4925,-99) ,
6, -951.286, 1, 0, 0.519851,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.500208,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.468736,-99) ,
4, 0.999524, 0, 0, 0.498661,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.451565,-99) ,
7, -1.57121, 0, 0, 0.49681,-99) ,
8, -4.03342, 1, 0, 0.49969,-99) );
// itree = 297
fBoostWeights.push_back(0.0513101);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -0.541537, 1, 1, 0.598535,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.533674,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.490796,-99) ,
5, 0.00596176, 0, 0, 0.496484,-99) ,
5, 0.00894349, 0, 0, 0.507756,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.330767,-99) ,
5, 0.023484, 1, 0, 0.503341,-99) );
// itree = 298
fBoostWeights.push_back(0.0242888);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.143048, 0, 1, 0.530441,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.52082,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.452638,-99) ,
9, -0.685375, 1, 0, 0.481748,-99) ,
3, 4.46703, 1, 0, 0.512431,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.507632,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.494674,-99) ,
6, -951.286, 1, 0, 0.501233,-99) ,
NN(
0,
0,
-1, -951.286, 0, -1, 0.481343,-99) ,
0, 0.493329, 0, 0, 0.498828,-99) ,
2, -0.0714185, 1, 0, 0.501143,-99) );
// itree = 299
fBoostWeights.push_back(0.0167774);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.893666, 0, 1, 0.506706,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.480954,-99) ,
9, 3.24397, 1, 0, 0.505226,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.467605,-99) ,
7, 2.14288, 1, 0, 0.503761,-99) );
// itree = 300
fBoostWeights.push_back(0.0207041);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -0.21455, 1, 1, 0.507503,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.506087,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.472815,-99) ,
6, -951.286, 0, 0, 0.48923,-99) ,
0, 0.5019, 1, 0, 0.504089,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.470088,-99) ,
9, 3.38031, 1, 0, 0.502255,-99) );
// itree = 301
fBoostWeights.push_back(0.0168706);
fForest.push_back(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.524474,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.505422,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.471505,-99) ,
7, 2.14289, 1, 0, 0.504193,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.456689,-99) ,
9, 2.70955, 1, 0, 0.502511,-99) ,
8, 1.99221, 0, 0, 0.503633,-99) );
// itree = 302
fBoostWeights.push_back(0.0213359);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.536377,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.502545,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.47142,-99) ,
9, -1.93447, 0, 0, 0.500319,-99) ,
8, -4.65268, 1, 0, 0.502687,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.533329,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.49251,-99) ,
9, 3.87519, 1, 0, 0.512401,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.502582,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.468915,-99) ,
6, -951.286, 0, 0, 0.481723,-99) ,
8, 1.04694, 0, 0, 0.489924,-99) ,
9, 0.71673, 1, 0, 0.49881,-99) );
// itree = 303
fBoostWeights.push_back(0.0138318);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.548355,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.487342,-99) ,
6, -951.286, 0, 0, 0.513103,-99) ,
NN(
0,
0,
-1, -1.51229, 0, -1, 0.496604,-99) ,
7, -1.2857, 1, 0, 0.498302,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.469659,-99) ,
2, -0.214218, 0, 0, 0.497112,-99) );
// itree = 304
fBoostWeights.push_back(0.0224216);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.587635,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.497024,-99) ,
7, 0.350829, 0, 0, 0.529781,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.537321,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.498897,-99) ,
4, 0.999524, 1, 0, 0.50176,-99) ,
8, -1.91976, 0, 0, 0.504946,-99) ,
NN(
NN(
0,
0,
-1, 3.6974, 1, 1, 0.518058,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.503546,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.46666,-99) ,
6, -951.286, 0, 0, 0.480646,-99) ,
8, 1.06495, 0, 0, 0.490656,-99) ,
9, 0.759337, 1, 0, 0.500779,-99) );
// itree = 305
fBoostWeights.push_back(0.0218094);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -1.45502, 1, 1, 0.526502,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.501174,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.464221,-99) ,
9, 0.422447, 1, 0, 0.499478,-99) ,
8, -1.81147, 0, 0, 0.501686,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.52819,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.506982,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.464311,-99) ,
6, -951.286, 0, 0, 0.480637,-99) ,
8, 2.23263, 0, 0, 0.487895,-99) ,
9, 0.71673, 1, 0, 0.497521,-99) );
// itree = 306
fBoostWeights.push_back(0.00988409);
fForest.push_back(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.536775,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.53282,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.497403,-99) ,
7, -1.15646, 1, 0, 0.517236,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.500054,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.444804,-99) ,
7, -1.57126, 0, 0, 0.497851,-99) ,
8, -4.36999, 1, 0, 0.499334,-99) ,
0, 0.505709, 0, 0, 0.500875,-99) );
// itree = 307
fBoostWeights.push_back(0.0377867);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -0.675704, 1, 1, 0.57953,-99) ,
NN(
0,
0,
-1, 0.000429183, 0, -1, 0.491931,-99) ,
5, 0.00901285, 0, 0, 0.501154,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.354182,-99) ,
5, 0.0236633, 1, 0, 0.49744,-99) );
// itree = 308
fBoostWeights.push_back(0.0156885);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.543079,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.499467,-99) ,
7, 1.61227, 1, 0, 0.515922,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.538735,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.496611,-99) ,
4, 0.999525, 1, 0, 0.498436,-99) ,
7, 1.28576, 0, 0, 0.501209,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.467209,-99) ,
2, -0.214166, 0, 0, 0.499808,-99) );
// itree = 309
fBoostWeights.push_back(0.0371973);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -3.63112, 0, 1, 0.525046,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.392211,-99) ,
7, -0.111087, 1, 0, 0.510937,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.506976,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.461663,-99) ,
4, 0.999524, 0, 0, 0.504718,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.508911,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.445725,-99) ,
6, -951.287, 0, 0, 0.467667,-99) ,
7, -0.428444, 0, 0, 0.498138,-99) ,
9, -1.17123, 1, 0, 0.501167,-99) );
// itree = 310
fBoostWeights.push_back(0.0196338);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.498092, 0, 1, 0.537259,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.579882,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.404093,-99) ,
9, 1.47015, 1, 0, 0.499183,-99) ,
6, -951.286, 0, 0, 0.517898,-99) ,
NN(
NN(
0,
0,
-1, 0.911623, 0, 1, 0.502162,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.470429,-99) ,
9, 3.50693, 1, 0, 0.500718,-99) ,
7, 1.57142, 0, 0, 0.502575,-99) );
// itree = 311
fBoostWeights.push_back(0.0114683);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.52399,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.500233,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.436561,-99) ,
9, -2.28134, 0, 0, 0.497805,-99) ,
7, -1.85692, 1, 0, 0.498788,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.503205,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.48139,-99) ,
0, 0.505346, 1, 0, 0.496296,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.453491,-99) ,
7, -0.428158, 0, 0, 0.483274,-99) ,
0, 0.502852, 1, 0, 0.496613,-99) );
// itree = 312
fBoostWeights.push_back(0.0514473);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.0108343, 0, 1, 0.559715,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.541144,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.487076,-99) ,
8, 1.14017, 0, 0, 0.490099,-99) ,
5, 0.00679148, 0, 0, 0.502654,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.356332,-99) ,
5, 0.0237713, 1, 0, 0.498973,-99) );
// itree = 313
fBoostWeights.push_back(0.0104);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.540081,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.498334,-99) ,
3, 9.03277, 0, 0, 0.49965,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.467018,-99) ,
4, 0.999683, 0, 0, 0.498355,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.458973,-99) ,
4, 0.999048, 0, 0, 0.497153,-99) );
// itree = 314
fBoostWeights.push_back(0.0158476);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.49877, 1, 1, 0.525325,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.503583,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.470231,-99) ,
9, -2.05171, 0, 0, 0.501915,-99) ,
7, -1.57142, 1, 0, 0.503404,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.507059,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.480044,-99) ,
6, -951.286, 0, 0, 0.493506,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.460679,-99) ,
0, 0.489791, 0, 0, 0.486149,-99) ,
0, 0.493329, 0, 0, 0.501126,-99) );
// itree = 315
fBoostWeights.push_back(0.0251241);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.547765,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.465255,-99) ,
4, 0.999977, 0, 0, 0.520987,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.515633,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.496536,-99) ,
4, 0.999955, 1, 0, 0.500072,-99) ,
7, 1.28578, 0, 0, 0.503314,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.469747,-99) ,
4, 0.999524, 0, 0, 0.501552,-99) );
// itree = 316
fBoostWeights.push_back(0.0180061);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.554758,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.496196,-99) ,
6, -951.286, 1, 0, 0.519568,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.502456,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.424505,-99) ,
7, -1.57126, 0, 0, 0.499657,-99) ,
8, -3.92379, 1, 0, 0.502561,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.450574,-99) ,
1, 0.0143116, 1, 0, 0.501131,-99) );
// itree = 317
fBoostWeights.push_back(0.0365672);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -3.73476, 0, 1, 0.525175,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.447863,-99) ,
7, -0.256244, 1, 0, 0.511145,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.512737,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.489704,-99) ,
9, 0.564542, 1, 0, 0.502598,-99) ,
NN(
0,
0,
-1, 0.0710585, 1, -1, 0.477056,-99) ,
7, -0.142744, 0, 0, 0.496228,-99) ,
9, -1.155, 1, 0, 0.499863,-99) );
// itree = 318
fBoostWeights.push_back(0.012803);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.564632,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.527663,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.493456,-99) ,
8, -1.00305, 0, 0, 0.504415,-99) ,
1, -0.00386971, 1, 0, 0.515213,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.546297,-99) ,
NN(
0,
0,
-1, 0.999683, 0, -1, 0.498046,-99) ,
4, 0.999049, 1, 0, 0.499576,-99) ,
7, 1.28571, 0, 0, 0.502059,-99) );
// itree = 319
fBoostWeights.push_back(0.0373541);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -4.07805, 0, 1, 0.537162,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.536014,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.476996,-99) ,
9, 0.938216, 0, 0, 0.495404,-99) ,
9, -1.4441, 1, 0, 0.515685,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.509823,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.493788,-99) ,
9, 0.313858, 1, 0, 0.502225,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.379347,-99) ,
9, -1.43231, 0, 0, 0.497273,-99) ,
7, -0.428444, 1, 0, 0.503011,-99) );
// itree = 320
fBoostWeights.push_back(0.0194867);
fForest.push_back(
NN(
NN(
0,
0,
-1, -951.287, 0, 1, 0.524908,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.508189,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.476881,-99) ,
2, -0.0714628, 0, 0, 0.502884,-99) ,
NN(
0,
0,
-1, 0.701096, 1, -1, 0.492648,-99) ,
8, -2.07047, 0, 0, 0.496385,-99) ,
7, 1.85714, 0, 0, 0.498413,-99) );
// itree = 321
fBoostWeights.push_back(0.00856142);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.562091,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.498082,-99) ,
8, -0.45416, 0, 0, 0.515525,-99) ,
NN(
0,
0,
-1, -4.45773, 1, 1, 0.502101,-99) ,
7, 1.57148, 0, 0, 0.503528,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.483653,-99) ,
2, 0.214083, 1, 0, 0.502804,-99) );
// itree = 322
fBoostWeights.push_back(0.0327065);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.595561,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.499803,-99) ,
8, 1.65039, 0, 0, 0.505951,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.512797,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.312139,-99) ,
6, -1.85705, 0, 0, 0.498017,-99) ,
6, -951.286, 1, 0, 0.502045,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.471563,-99) ,
7, 2.14288, 1, 0, 0.500859,-99) );
// itree = 323
fBoostWeights.push_back(0.021262);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 1.40043, 0, 1, 0.537183,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.484773,-99) ,
6, -951.286, 1, 0, 0.517301,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.534072,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.495131,-99) ,
8, -0.731913, 0, 0, 0.497688,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.454274,-99) ,
9, 1.93396, 1, 0, 0.49629,-99) ,
8, 0.299902, 0, 0, 0.498904,-99) );
// itree = 324
fBoostWeights.push_back(0.0133538);
fForest.push_back(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.541819,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.559208,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.497142,-99) ,
6, -951.286, 1, 0, 0.522002,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.500403,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.461948,-99) ,
7, -1.53062, 0, 0, 0.498767,-99) ,
8, -4.03342, 1, 0, 0.501808,-99) ,
7, 2.14285, 0, 0, 0.503558,-99) );
// itree = 325
fBoostWeights.push_back(0.0197747);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.53667,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.496268,-99) ,
0, 0.49809, 1, 0, 0.516992,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.513784,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.495522,-99) ,
9, -0.959748, 1, 0, 0.499343,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.51476,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.415465,-99) ,
7, -0.967779, 1, 0, 0.475002,-99) ,
9, -1.85282, 0, 0, 0.497502,-99) ,
7, -1.57117, 1, 0, 0.498722,-99) );
// itree = 326
fBoostWeights.push_back(0.0136769);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.542764,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.523132,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.49756,-99) ,
7, 1.57142, 0, 0, 0.500247,-99) ,
3, 9.00889, 0, 0, 0.501751,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.465586,-99) ,
4, 0.999048, 0, 0, 0.50064,-99) );
// itree = 327
fBoostWeights.push_back(0.0180018);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.548501,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.500081,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.481356,-99) ,
7, -0.91605, 1, 0, 0.491214,-99) ,
6, -951.286, 1, 0, 0.513832,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.503788,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.475522,-99) ,
4, 0.999909, 0, 0, 0.500506,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.473075,-99) ,
4, 0.999048, 0, 0, 0.49972,-99) ,
8, -4.03342, 1, 0, 0.501483,-99) );
// itree = 328
fBoostWeights.push_back(0.0597177);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.57073,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.512448,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.422707,-99) ,
7, -1.57128, 0, 0, 0.507454,-99) ,
8, -4.21681, 1, 0, 0.512225,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.525069,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.459394,-99) ,
6, -0.918336, 0, 0, 0.512397,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.24409,-99) ,
6, -2.14283, 0, 0, 0.498722,-99) ,
6, -951.286, 1, 0, 0.505547,-99) );
// itree = 329
fBoostWeights.push_back(0.0175438);
fForest.push_back(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.530634,-99) ,
NN(
0,
0,
-1, -2.13247, 0, -1, 0.492081,-99) ,
7, -1.85713, 1, 0, 0.493528,-99) );
// itree = 330
fBoostWeights.push_back(0.0173021);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.536736,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.503625,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.477823,-99) ,
9, -1.76003, 0, 0, 0.501402,-99) ,
8, -4.66802, 1, 0, 0.503249,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.503819,-99) ,
NN(
0,
0,
-1, 0.63529, 0, -1, 0.471762,-99) ,
8, 2.3104, 0, 0, 0.48212,-99) ,
9, 2.01783, 1, 0, 0.500458,-99) );
// itree = 331
fBoostWeights.push_back(0.0307858);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.553775,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.50175,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.450244,-99) ,
7, -1.69352, 0, 0, 0.474775,-99) ,
6, -951.286, 0, 0, 0.508701,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.504021,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.454659,-99) ,
7, 1.77563, 1, 0, 0.499837,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.501764,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.302488,-99) ,
6, -1.85716, 0, 0, 0.485297,-99) ,
6, -951.286, 1, 0, 0.492513,-99) ,
7, -1.2853, 1, 0, 0.494164,-99) );
// itree = 332
fBoostWeights.push_back(0.0171657);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.529337,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.496598,-99) ,
7, -1.91138, 0, 0, 0.512502,-99) ,
NN(
0,
0,
-1, -1.91576, 0, -1, 0.491917,-99) ,
7, -1.57125, 1, 0, 0.493215,-99) );
// itree = 333
fBoostWeights.push_back(0.0228022);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.557623,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.516767,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.475773,-99) ,
8, -2.08677, 0, 0, 0.505782,-99) ,
1, 0.00373063, 0, 0, 0.515855,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.532273,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.500542,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.48579,-99) ,
6, -951.286, 1, 0, 0.493312,-99) ,
4, 0.999524, 1, 0, 0.495396,-99) ,
7, 1.28571, 0, 0, 0.498649,-99) );
// itree = 334
fBoostWeights.push_back(0.0116013);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.52092,-99) ,
NN(
0,
0,
-1, 0.214255, 1, -1, 0.497894,-99) ,
0, 0.502127, 0, 0, 0.498965,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.518581,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.483525,-99) ,
6, -951.286, 0, 0, 0.501614,-99) ,
NN(
0,
0,
-1, -0.223635, 1, -1, 0.473215,-99) ,
7, 0.429411, 0, 0, 0.484392,-99) ,
0, 0.502852, 1, 0, 0.496929,-99) );
// itree = 335
fBoostWeights.push_back(0.0221199);
fForest.push_back(
NN(
NN(
0,
0,
-1, -2.41761, 0, 1, 0.526922,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.552903,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.493346,-99) ,
8, 0.708619, 0, 0, 0.495447,-99) ,
NN(
0,
0,
-1, 1.00141, 0, -1, 0.472251,-99) ,
9, 3.00204, 1, 0, 0.493709,-99) ,
8, -4.36999, 1, 0, 0.496248,-99) );
// itree = 336
fBoostWeights.push_back(0.0178927);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.142883, 1, 1, 0.536211,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.477103,-99) ,
6, -951.286, 1, 0, 0.511529,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.525431,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.496277,-99) ,
8, -4.73474, 1, 0, 0.497579,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.429973,-99) ,
9, 2.21328, 1, 0, 0.495619,-99) ,
8, 0.734616, 0, 0, 0.497178,-99) );
// itree = 337
fBoostWeights.push_back(0.0219089);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -0.0411091, 1, 1, 0.512875,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.516016,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.493993,-99) ,
7, 1.00012, 0, 0, 0.498965,-99) ,
3, 1.85267, 1, 0, 0.505225,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.469767,-99) ,
3, 9.32353, 1, 0, 0.504135,-99) );
// itree = 338
fBoostWeights.push_back(0.0209587);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.506682,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.470873,-99) ,
7, -1.57118, 0, 0, 0.505131,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.45315,-99) ,
9, -2.58863, 0, 0, 0.503506,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.511059,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.452192,-99) ,
7, 1.00303, 0, 0, 0.475998,-99) ,
9, 3.08085, 1, 0, 0.501679,-99) );
// itree = 339
fBoostWeights.push_back(0.0274389);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.593729,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.497851,-99) ,
7, 0.542086, 0, 0, 0.531093,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.50508,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.475489,-99) ,
2, -0.0699441, 0, 0, 0.500131,-99) ,
9, 0.260284, 1, 0, 0.506546,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.548138,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.496699,-99) ,
7, -1.62199, 1, 0, 0.501209,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.51052,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.438329,-99) ,
9, -0.112271, 0, 0, 0.462788,-99) ,
7, 0.615819, 1, 0, 0.494405,-99) ,
8, -2.48512, 0, 0, 0.500431,-99) );
// itree = 340
fBoostWeights.push_back(0.0140323);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -4.15886, 1, 1, 0.505076,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.466846,-99) ,
7, -1.57142, 0, 0, 0.50354,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.469717,-99) ,
9, -2.51572, 0, 0, 0.5024,-99) );
// itree = 341
fBoostWeights.push_back(0.0295237);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.541184,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.498775,-99) ,
0, 0.498091, 1, 0, 0.520068,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.543449,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.497957,-99) ,
8, 1.2702, 0, 0, 0.501609,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.507452,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.289257,-99) ,
6, -1.85705, 0, 0, 0.490495,-99) ,
6, -951.286, 1, 0, 0.496041,-99) ,
7, -1.57124, 1, 0, 0.497531,-99) );
// itree = 342
fBoostWeights.push_back(0.0338099);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -0.541537, 1, 1, 0.568686,-99) ,
NN(
0,
0,
-1, 0.00043108, 0, -1, 0.492698,-99) ,
5, 0.00905262, 0, 0, 0.500712,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.362172,-99) ,
5, 0.0237713, 1, 0, 0.497224,-99) );
// itree = 343
fBoostWeights.push_back(0.0193428);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.509255,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.494915,-99) ,
0, 0.500812, 1, 0, 0.504878,-99) ,
NN(
0,
0,
-1, 0.49224, 1, -1, 0.487367,-99) ,
0, 0.493329, 0, 0, 0.50257,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.471789,-99) ,
9, 3.35768, 1, 0, 0.500883,-99) );
// itree = 344
fBoostWeights.push_back(0.0183351);
fForest.push_back(
NN(
NN(
0,
0,
-1, -1.9794, 0, 1, 0.526285,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.527913,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.506063,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.491979,-99) ,
6, -951.286, 1, 0, 0.49902,-99) ,
7, 2.12924, 0, 0, 0.500377,-99) ,
7, -1.57125, 1, 0, 0.502,-99) );
// itree = 345
fBoostWeights.push_back(0.0139469);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.999048, 1, 1, 0.504327,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.459122,-99) ,
7, 2.14284, 1, 0, 0.502717,-99) ,
NN(
0,
0,
-1, 1.99734, 0, -1, 0.476967,-99) ,
9, 2.84504, 1, 0, 0.500727,-99) );
// itree = 346
fBoostWeights.push_back(0.0156435);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.540507,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.497827,-99) ,
9, -0.720988, 1, 0, 0.520151,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.537228,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.497722,-99) ,
3, 9.13153, 0, 0, 0.499095,-99) ,
4, 0.999524, 1, 0, 0.500427,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.523296,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.46781,-99) ,
3, 1.74855, 0, 0, 0.500075,-99) ,
NN(
0,
0,
-1, 0.478118, 0, -1, 0.467902,-99) ,
8, 1.14774, 0, 0, 0.486803,-99) ,
9, 2.0872, 1, 0, 0.498675,-99) );
// itree = 347
fBoostWeights.push_back(0.017535);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.53362,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.537902,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.499812,-99) ,
7, -1.70458, 1, 0, 0.501908,-99) ,
8, -1.73711, 0, 0, 0.504162,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.519006,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.510558,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.480216,-99) ,
0, 0.503986, 0, 0, 0.483891,-99) ,
0, 0.492376, 1, 0, 0.487925,-99) ,
9, 0.71673, 1, 0, 0.499279,-99) );
// itree = 348
fBoostWeights.push_back(0.0202226);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.544223,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.49467,-99) ,
7, -0.86279, 1, 0, 0.522727,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.505558,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.484216,-99) ,
3, 5.85242, 1, 0, 0.503511,-99) ,
8, -3.9435, 1, 0, 0.506191,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.468551,-99) ,
3, 9.38661, 1, 0, 0.505049,-99) );
// itree = 349
fBoostWeights.push_back(0.0175647);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.576648,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.489871,-99) ,
9, -1.52827, 0, 0, 0.518016,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.503196,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.481691,-99) ,
7, -0.99984, 0, 0, 0.501123,-99) ,
8, -3.81798, 1, 0, 0.503165,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.475295,-99) ,
9, -2.26819, 0, 0, 0.501739,-99) );
// itree = 350
fBoostWeights.push_back(0.0365435);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -951.286, 1, 1, 0.522772,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.5299,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.465448,-99) ,
6, -951.286, 0, 0, 0.48838,-99) ,
8, -3.33462, 1, 0, 0.506712,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.51933,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.493091,-99) ,
9, -0.168468, 1, 0, 0.500947,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.500962,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.373104,-99) ,
9, -1.4187, 0, 0, 0.466917,-99) ,
8, -3.40863, 0, 0, 0.495926,-99) ,
7, -0.428421, 1, 0, 0.49925,-99) );
// itree = 351
fBoostWeights.push_back(0.0259421);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.541211,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.49351,-99) ,
6, -951.286, 0, 0, 0.514415,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.508183,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.489346,-99) ,
2, -0.0307584, 1, 0, 0.494565,-99) ,
7, -0.999839, 1, 0, 0.497647,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.45513,-99) ,
2, 0.214083, 1, 0, 0.496135,-99) );
// itree = 352
fBoostWeights.push_back(0.0317616);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.517538,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.49172,-99) ,
4, 0.999994, 0, 0, 0.505008,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.50723,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.427859,-99) ,
9, -0.478165, 1, 0, 0.475083,-99) ,
4, 0.999864, 0, 0, 0.502327,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.451643,-99) ,
4, 0.999048, 0, 0, 0.500818,-99) );
// itree = 353
fBoostWeights.push_back(0.0184378);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.551188,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.524,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.477096,-99) ,
6, -951.286, 1, 0, 0.505803,-99) ,
7, 1.28577, 0, 0, 0.515352,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.529863,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.496832,-99) ,
4, 0.999524, 1, 0, 0.498759,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.459985,-99) ,
3, 9.33163, 1, 0, 0.49742,-99) ,
8, 0.0846499, 0, 0, 0.499925,-99) );
// itree = 354
fBoostWeights.push_back(0.022008);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.556623,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.507825,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.485185,-99) ,
9, 2.34497, 1, 0, 0.505425,-99) ,
7, 2.14284, 0, 0, 0.50758,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.481622,-99) ,
4, 0.999524, 0, 0, 0.506203,-99) );
// itree = 355
fBoostWeights.push_back(0.0186455);
fForest.push_back(
NN(
NN(
0,
0,
-1, -1.97944, 0, 1, 0.525872,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.536842,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.509888,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.494194,-99) ,
2, 0.0296468, 0, 0, 0.498359,-99) ,
2, -0.215065, 1, 0, 0.500066,-99) ,
7, -1.57127, 1, 0, 0.50168,-99) );
// itree = 356
fBoostWeights.push_back(0.03825);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -0.480915, 1, 1, 0.55154,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.505468,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.474692,-99) ,
5, 0.00112851, 0, 0, 0.498327,-99) ,
5, 0.00789923, 0, 0, 0.505716,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.354505,-99) ,
5, 0.0236981, 1, 0, 0.501884,-99) );
// itree = 357
fBoostWeights.push_back(0.0270815);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.999524, 1, 1, 0.506859,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.513525,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.471382,-99) ,
7, 1.00008, 0, 0, 0.489368,-99) ,
9, 0.371813, 1, 0, 0.500366,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.453591,-99) ,
3, 9.37272, 1, 0, 0.498996,-99) );
// itree = 358
fBoostWeights.push_back(0.0116005);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.53129,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.49731,-99) ,
4, 0.999048, 1, 0, 0.498305,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.469421,-99) ,
3, 7.1777, 1, 0, 0.497012,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.45893,-99) ,
3, 9.38661, 1, 0, 0.4959,-99) );
// itree = 359
fBoostWeights.push_back(0.0231983);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.568062,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.531627,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.488552,-99) ,
8, -1.04975, 0, 0, 0.503186,-99) ,
1, -0.00386971, 1, 0, 0.515278,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.526016,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.486692,-99) ,
9, -1.70024, 1, 0, 0.506218,-99) ,
NN(
0,
0,
-1, -1.49675, 0, -1, 0.494111,-99) ,
7, -0.959048, 1, 0, 0.496487,-99) ,
7, 1.28577, 0, 0, 0.499468,-99) );
// itree = 360
fBoostWeights.push_back(0.0215337);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.512187,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.493786,-99) ,
4, 0.999995, 0, 0, 0.502684,-99) ,
NN(
0,
0,
-1, -0.30228, 1, -1, 0.481061,-99) ,
4, 0.999887, 0, 0, 0.50083,-99) ,
NN(
0,
0,
-1, 0.498089, 0, -1, 0.474421,-99) ,
4, 0.999524, 0, 0, 0.499446,-99) );
// itree = 361
fBoostWeights.push_back(0.00961993);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.517201,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.501003,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.491709,-99) ,
9, 1.67841, 1, 0, 0.499276,-99) ,
8, -4.21358, 1, 0, 0.500462,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.453052,-99) ,
9, -2.52271, 0, 0, 0.498863,-99) );
// itree = 362
fBoostWeights.push_back(0.01258);
fForest.push_back(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.538394,-99) ,
NN(
NN(
0,
0,
-1, 0.86527, 0, 1, 0.503359,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.471484,-99) ,
9, 3.24276, 1, 0, 0.501531,-99) ,
7, 2.14284, 0, 0, 0.503165,-99) );
// itree = 363
fBoostWeights.push_back(0.0163965);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.54232,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.504629,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.491973,-99) ,
3, 2.2273, 1, 0, 0.49886,-99) ,
2, 0.215976, 0, 0, 0.500336,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.470598,-99) ,
3, 8.96288, 1, 0, 0.499265,-99) );
// itree = 364
fBoostWeights.push_back(0.0114825);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.565639,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.491048,-99) ,
6, -951.286, 0, 0, 0.517031,-99) ,
NN(
0,
0,
-1, -2.26014, 0, -1, 0.498397,-99) ,
8, -0.0309768, 0, 0, 0.500538,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.46583,-99) ,
9, 4.14387, 1, 0, 0.49933,-99) );
// itree = 365
fBoostWeights.push_back(0.0178407);
fForest.push_back(
NN(
NN(
0,
0,
-1, -1.97937, 0, 1, 0.528647,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.50419,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.467121,-99) ,
7, 2.34693, 1, 0, 0.503073,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.514367,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.42251,-99) ,
7, -0.967779, 1, 0, 0.478966,-99) ,
9, -1.85949, 0, 0, 0.501273,-99) ,
7, -1.57122, 1, 0, 0.503029,-99) );
// itree = 366
fBoostWeights.push_back(0.0108673);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.51887,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.4984,-99) ,
7, -0.918329, 1, 0, 0.500663,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.467728,-99) ,
7, -1.57142, 0, 0, 0.499354,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.472942,-99) ,
9, -2.50949, 0, 0, 0.498434,-99) );
// itree = 367
fBoostWeights.push_back(0.0185656);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.543463,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.514788,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.466033,-99) ,
7, 2.04767, 1, 0, 0.493047,-99) ,
1, 0.00152331, 0, 0, 0.511898,-99) ,
NN(
0,
0,
-1, 0.505709, 1, -1, 0.493294,-99) ,
7, 1.57147, 0, 0, 0.495277,-99) );
// itree = 368
fBoostWeights.push_back(0.008142);
fForest.push_back(
NN(
NN(
0,
0,
-1, 0.999524, 1, 1, 0.503217,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.477082,-99) ,
0, 0.490472, 0, 0, 0.502085,-99) );
// itree = 369
fBoostWeights.push_back(0.0222829);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.609005,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.491162,-99) ,
9, -0.678484, 0, 0, 0.530021,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.476225,-99) ,
7, -2.02014, 0, 0, 0.516839,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.504773,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.461624,-99) ,
9, -1.82661, 0, 0, 0.50183,-99) ,
NN(
0,
0,
-1, 1.46042, 0, -1, 0.483549,-99) ,
9, 2.33489, 1, 0, 0.499717,-99) ,
7, -1.28549, 1, 0, 0.501465,-99) );
// itree = 370
fBoostWeights.push_back(0.0187436);
fForest.push_back(
NN(
NN(
0,
0,
-1, -2.04738, 0, 1, 0.518145,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.502254,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.468257,-99) ,
7, -0.700442, 0, 0, 0.498113,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.51652,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.408824,-99) ,
7, -0.967377, 1, 0, 0.474533,-99) ,
9, -1.85282, 0, 0, 0.496374,-99) ,
7, -1.57119, 1, 0, 0.497747,-99) );
// itree = 371
fBoostWeights.push_back(0.0214036);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.555133,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.530818,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.447515,-99) ,
9, -1.91945, 1, 0, 0.501233,-99) ,
9, -0.147561, 0, 0, 0.515436,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.530264,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.49219,-99) ,
7, 0.143104, 0, 0, 0.513394,-99) ,
NN(
0,
0,
-1, 0.503033, 1, -1, 0.494511,-99) ,
0, 0.503804, 0, 0, 0.496426,-99) ,
7, -1.28554, 1, 0, 0.498389,-99) );
// itree = 372
fBoostWeights.push_back(0.0198404);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.527435,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.512563,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.493121,-99) ,
7, -0.999989, 1, 0, 0.495236,-99) ,
8, -4.17862, 1, 0, 0.497546,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.461185,-99) ,
9, -2.52667, 0, 0, 0.49634,-99) );
// itree = 373
fBoostWeights.push_back(0.0143712);
fForest.push_back(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.527842,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.504567,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.477397,-99) ,
7, -1.57141, 0, 0, 0.503396,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.473798,-99) ,
9, -2.5359, 0, 0, 0.5024,-99) ,
8, 1.99221, 0, 0, 0.50373,-99) );
// itree = 374
fBoostWeights.push_back(0.0223698);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.52802,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.49037,-99) ,
9, -1.04725, 1, 0, 0.508838,-99) ,
NN(
0,
0,
-1, -1.15357, 0, -1, 0.494492,-99) ,
7, -0.142729, 1, 0, 0.499867,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.473294,-99) ,
9, -2.32196, 0, 0, 0.49864,-99) );
// itree = 375
fBoostWeights.push_back(0.0277446);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.542633,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.517067,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.481852,-99) ,
8, 2.17023, 0, 0, 0.499712,-99) ,
9, 2.58142, 1, 0, 0.513901,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.525543,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.488488,-99) ,
3, 4.7767, 1, 0, 0.512577,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.502827,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.48135,-99) ,
2, 0.00319063, 0, 0, 0.492809,-99) ,
2, -0.0716195, 1, 0, 0.496123,-99) ,
8, 0.0846499, 0, 0, 0.498567,-99) );
// itree = 376
fBoostWeights.push_back(0.00966965);
fForest.push_back(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.527595,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.528815,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.499204,-99) ,
7, -1.77551, 1, 0, 0.500615,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.462216,-99) ,
7, 2.14285, 1, 0, 0.499144,-99) ,
8, 1.83089, 0, 0, 0.500723,-99) );
// itree = 377
fBoostWeights.push_back(0.0171174);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.538727,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.49628,-99) ,
3, 4.7767, 1, 0, 0.524534,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.484496,-99) ,
7, -0.712839, 0, 0, 0.515653,-99) ,
NN(
NN(
0,
0,
-1, 0.498089, 1, 1, 0.531143,-99) ,
NN(
0,
0,
-1, -2.10989, 0, -1, 0.496499,-99) ,
7, -1.57124, 1, 0, 0.498728,-99) ,
2, -0.0710073, 1, 0, 0.501619,-99) );
// itree = 378
fBoostWeights.push_back(0.0152501);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 2.14279, 0, 1, 0.505814,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.507373,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.463362,-99) ,
0, 0.505981, 0, 0, 0.484895,-99) ,
0, 0.504757, 1, 0, 0.504543,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.470019,-99) ,
2, 0.214083, 1, 0, 0.503339,-99) );
// itree = 379
fBoostWeights.push_back(0.0133068);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -0.673332, 1, 1, 0.503502,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.526443,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.441208,-99) ,
9, -0.556736, 0, 0, 0.482416,-99) ,
7, -1.28555, 0, 0, 0.502059,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.483826,-99) ,
9, -2.37309, 0, 0, 0.501259,-99) );
// itree = 380
fBoostWeights.push_back(0.0131052);
fForest.push_back(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.517486,-99) ,
NN(
0,
0,
-1, 2.55198, 1, -1, 0.494114,-99) ,
8, 1.74434, 0, 0, 0.495456,-99) );
// itree = 381
fBoostWeights.push_back(0.0415591);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.521473,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.496976,-99) ,
9, 1.63182, 1, 0, 0.514787,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.51462,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.479424,-99) ,
6, -951.286, 0, 0, 0.492832,-99) ,
7, 0.142989, 0, 0, 0.506964,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.520319,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.48602,-99) ,
9, -1.81784, 0, 0, 0.505652,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.515694,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.434411,-99) ,
9, -0.695294, 0, 0, 0.460834,-99) ,
7, -0.0343401, 1, 0, 0.49174,-99) ,
8, -3.05609, 0, 0, 0.501582,-99) );
// itree = 382
fBoostWeights.push_back(0.0262862);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.518409,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.48294,-99) ,
8, -2.66484, 0, 0, 0.508972,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.503289,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.479464,-99) ,
9, -0.166531, 1, 0, 0.496198,-99) ,
7, 0.428647, 0, 0, 0.501205,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.464553,-99) ,
9, 3.80655, 1, 0, 0.499718,-99) );
// itree = 383
fBoostWeights.push_back(0.0197576);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.538807,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.530546,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.493325,-99) ,
7, 2.14288, 0, 0, 0.494831,-99) ,
3, 9.13835, 0, 0, 0.49621,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.467198,-99) ,
4, 0.999524, 0, 0, 0.4947,-99) );
// itree = 384
fBoostWeights.push_back(0.0144326);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.145503, 1, 1, 0.519094,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.506129,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.494775,-99) ,
8, -1.68874, 0, 0, 0.498537,-99) ,
0, 0.491424, 1, 0, 0.499931,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.467628,-99) ,
3, 9.38661, 1, 0, 0.49897,-99) );
// itree = 385
fBoostWeights.push_back(0.0281034);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.584346,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.494838,-99) ,
7, -0.444685, 0, 0, 0.548686,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.504273,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.450133,-99) ,
7, 1.13497, 1, 0, 0.500736,-99) ,
8, -2.18814, 0, 0, 0.505577,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.532376,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.489729,-99) ,
8, 1.60292, 0, 0, 0.496819,-99) ,
NN(
0,
0,
-1, 0.498091, 1, -1, 0.460321,-99) ,
2, 0.0719535, 1, 0, 0.491436,-99) ,
9, 0.341677, 1, 0, 0.5003,-99) );
// itree = 386
fBoostWeights.push_back(0.0122205);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 9.13153, 0, 1, 0.503918,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.470284,-99) ,
4, 0.999728, 0, 0, 0.502295,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.463513,-99) ,
4, 0.999048, 0, 0, 0.501122,-99) );
// itree = 387
fBoostWeights.push_back(0.0215636);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.535005,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.517516,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.494849,-99) ,
8, -0.762665, 0, 0, 0.500115,-99) ,
8, -4.19339, 1, 0, 0.50252,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.462432,-99) ,
9, -2.52271, 0, 0, 0.501222,-99) );
// itree = 388
fBoostWeights.push_back(0.015329);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.543008,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.513928,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.494851,-99) ,
0, 0.491424, 1, 0, 0.496086,-99) ,
2, 0.214274, 0, 0, 0.49771,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.471278,-99) ,
3, 9.37272, 1, 0, 0.496911,-99) );
// itree = 389
fBoostWeights.push_back(0.0195177);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.539896,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.506186,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.481053,-99) ,
9, 1.45886, 1, 0, 0.504019,-99) ,
8, 0.414386, 0, 0, 0.505869,-99) ,
NN(
0,
0,
-1, 2.30984, 1, -1, 0.478842,-99) ,
9, 3.08085, 1, 0, 0.504118,-99) );
// itree = 390
fBoostWeights.push_back(0.0131255);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.518468,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.460874,-99) ,
2, -0.0685946, 0, 0, 0.508847,-99) ,
NN(
0,
0,
-1, 1.31073, 1, -1, 0.498318,-99) ,
8, -0.580593, 0, 0, 0.500391,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.467019,-99) ,
9, -2.50949, 0, 0, 0.499297,-99) );
// itree = 391
fBoostWeights.push_back(0.0350896);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.517713,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.490497,-99) ,
9, 2.51959, 1, 0, 0.513388,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.500078,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.451159,-99) ,
2, 0.0696619, 1, 0, 0.492907,-99) ,
7, 0.142937, 0, 0, 0.50616,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.52542,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.495532,-99) ,
6, -951.286, 1, 0, 0.508515,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.52374,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.449841,-99) ,
9, -0.687577, 0, 0, 0.469266,-99) ,
7, -0.231791, 1, 0, 0.49261,-99) ,
8, -3.05747, 0, 0, 0.501391,-99) );
// itree = 392
fBoostWeights.push_back(0.0245817);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.544572,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.496132,-99) ,
9, 2.97569, 1, 0, 0.516526,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.506654,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.482924,-99) ,
9, 0.494502, 1, 0, 0.502502,-99) ,
8, 0.602337, 0, 0, 0.503838,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.518112,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.481172,-99) ,
9, 1.40802, 1, 0, 0.500374,-99) ,
NN(
0,
0,
-1, -2.67493, 1, -1, 0.470856,-99) ,
8, -2.18733, 0, 0, 0.491498,-99) ,
7, 1.00007, 1, 0, 0.501146,-99) );
// itree = 393
fBoostWeights.push_back(0.0162097);
fForest.push_back(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.528373,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.524308,-99) ,
NN(
0,
0,
-1, -0.132615, 0, -1, 0.493595,-99) ,
2, -0.214257, 1, 0, 0.494968,-99) ,
7, 2.1428, 0, 0, 0.496387,-99) );
// itree = 394
fBoostWeights.push_back(0.0238959);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.558774,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.491241,-99) ,
7, -0.142781, 0, 0, 0.528106,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.519769,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.481965,-99) ,
8, 0.88372, 0, 0, 0.500108,-99) ,
9, 1.50023, 1, 0, 0.50925,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.537164,-99) ,
NN(
0,
0,
-1, -2.10909, 0, -1, 0.493926,-99) ,
7, -1.85669, 1, 0, 0.495554,-99) ,
8, -1.33695, 0, 0, 0.49929,-99) );
// itree = 395
fBoostWeights.push_back(0.0115285);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.54597,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.498291,-99) ,
9, 4.11156, 1, 0, 0.519867,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.502348,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.465738,-99) ,
7, 2.14284, 1, 0, 0.50114,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.471415,-99) ,
9, 2.30417, 1, 0, 0.499694,-99) ,
8, 1.45301, 0, 0, 0.501034,-99) );
// itree = 396
fBoostWeights.push_back(0.0170683);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 2.50594, 1, 1, 0.533388,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.486228,-99) ,
2, -0.0455389, 0, 0, 0.522837,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.502849,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.465054,-99) ,
9, -2.51088, 0, 0, 0.501257,-99) ,
NN(
0,
0,
-1, -0.458108, 0, -1, 0.480295,-99) ,
9, 1.42516, 1, 0, 0.499791,-99) ,
8, 0.0767756, 0, 0, 0.502946,-99) );
// itree = 397
fBoostWeights.push_back(0.0246279);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -0.73122, 0, 1, 0.535368,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.506683,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.468728,-99) ,
2, -0.0695244, 0, 0, 0.500304,-99) ,
9, 1.50023, 1, 0, 0.511586,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.520331,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.49264,-99) ,
8, -1.8414, 0, 0, 0.495235,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.459275,-99) ,
7, 1.85609, 1, 0, 0.493775,-99) ,
8, -1.31932, 0, 0, 0.498675,-99) );
// itree = 398
fBoostWeights.push_back(0.0187271);
fForest.push_back(
NN(
NN(
0,
0,
-1, -2.38401, 0, 1, 0.519823,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.529709,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.497703,-99) ,
6, -951.286, 0, 0, 0.509578,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.5095,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.493149,-99) ,
2, 0.0714933, 0, 0, 0.495689,-99) ,
8, -0.906103, 0, 0, 0.499065,-99) ,
8, -4.36999, 1, 0, 0.5006,-99) );
// itree = 399
fBoostWeights.push_back(0.0185289);
fForest.push_back(
NN(
NN(
0,
0,
-1, 1.85718, 0, 1, 0.518541,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.541723,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.501646,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.418695,-99) ,
9, -2.34414, 0, 0, 0.498281,-99) ,
7, -1.85714, 1, 0, 0.499938,-99) ,
8, -1.06408, 0, 0, 0.504463,-99) );
// itree = 400
fBoostWeights.push_back(0.0106046);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.538818,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.501881,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.465843,-99) ,
4, 0.999683, 0, 0, 0.500482,-99) ,
7, 2.14289, 0, 0, 0.502065,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.473035,-99) ,
4, 0.999048, 0, 0, 0.501163,-99) );
// itree = 401
fBoostWeights.push_back(0.0201327);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.53391,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.505166,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.465068,-99) ,
9, 3.05633, 1, 0, 0.502729,-99) ,
7, 2.14287, 0, 0, 0.504088,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.520458,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.490715,-99) ,
0, 0.493523, 0, 0, 0.496288,-99) ,
NN(
0,
0,
-1, 0.494611, 0, -1, 0.471463,-99) ,
0, 0.494145, 1, 0, 0.489578,-99) ,
0, 0.495233, 0, 0, 0.500554,-99) );
// itree = 402
fBoostWeights.push_back(0.00964497);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.534482,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.498863,-99) ,
0, 0.498091, 1, 0, 0.516816,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.500004,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.462493,-99) ,
9, -1.98156, 0, 0, 0.497631,-99) ,
7, -1.61207, 1, 0, 0.498857,-99) ,
NN(
0,
0,
-1, 2.2925, 1, -1, 0.474212,-99) ,
7, 1.85714, 1, 0, 0.497261,-99) );
// itree = 403
fBoostWeights.push_back(0.0236986);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.567961,-99) ,
NN(
0,
0,
-1, 0.490562, 0, -1, 0.482246,-99) ,
7, 0.714372, 0, 0, 0.509767,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.52198,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.517274,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.491501,-99) ,
8, 2.07299, 0, 0, 0.492756,-99) ,
2, 0.213937, 0, 0, 0.493803,-99) ,
0, 0.492376, 1, 0, 0.495403,-99) );
// itree = 404
fBoostWeights.push_back(0.0191473);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.536778,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.507993,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.492973,-99) ,
8, -1.01921, 0, 0, 0.496717,-99) ,
4, 0.999524, 1, 0, 0.498832,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.466586,-99) ,
3, 9.32353, 1, 0, 0.497854,-99) );
// itree = 405
fBoostWeights.push_back(0.0119729);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.537241,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.498742,-99) ,
0, 0.499043, 1, 0, 0.521225,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.502484,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.476989,-99) ,
9, -1.8542, 0, 0, 0.500605,-99) ,
7, -1.57141, 1, 0, 0.501889,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.471121,-99) ,
2, 0.214015, 1, 0, 0.500785,-99) );
// itree = 406
fBoostWeights.push_back(0.0336133);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.53987,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.532394,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.448923,-99) ,
7, -1.20777, 1, 0, 0.498969,-99) ,
9, -1.9018, 0, 0, 0.513353,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.51014,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.47782,-99) ,
8, -2.69138, 0, 0, 0.502498,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.504259,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.477816,-99) ,
6, -951.286, 0, 0, 0.49004,-99) ,
7, 0.428668, 0, 0, 0.4957,-99) ,
8, -4.03342, 1, 0, 0.497919,-99) );
// itree = 407
fBoostWeights.push_back(0.0202206);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -1.25512, 1, 1, 0.520929,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.52428,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.497501,-99) ,
2, 0.0714384, 0, 0, 0.502132,-99) ,
7, -0.142536, 1, 0, 0.509822,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.526393,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.494168,-99) ,
4, 0.999524, 1, 0, 0.496091,-99) ,
NN(
0,
0,
-1, -1.01473, 0, -1, 0.485083,-99) ,
9, 0.969131, 1, 0, 0.493258,-99) ,
0, 0.496186, 1, 0, 0.498606,-99) );
// itree = 408
fBoostWeights.push_back(0.034439);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.54859,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.534296,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.493132,-99) ,
8, -3.76746, 1, 0, 0.49926,-99) ,
9, 3.24397, 0, 0, 0.502566,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.599895,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.497005,-99) ,
7, 1.85741, 0, 0, 0.503609,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.26164,-99) ,
6, -2.14285, 0, 0, 0.491172,-99) ,
6, -951.286, 1, 0, 0.496899,-99) );
// itree = 409
fBoostWeights.push_back(0.0506541);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.518266,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.495647,-99) ,
7, 1.47622, 1, 0, 0.514992,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.504727,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.455787,-99) ,
9, -0.947708, 1, 0, 0.481467,-99) ,
7, -0.999854, 0, 0, 0.509393,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.519222,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.457435,-99) ,
6, -1.16382, 0, 0, 0.510751,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.26245,-99) ,
6, -2.1431, 0, 0, 0.498129,-99) ,
6, -951.286, 1, 0, 0.503835,-99) );
// itree = 410
fBoostWeights.push_back(0.0146155);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.497138, 1, 1, 0.529285,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.478481,-99) ,
7, 2.31976, 1, 0, 0.516089,-99) ,
NN(
0,
0,
-1, 2.36507, 1, -1, 0.495072,-99) ,
7, 1.57148, 0, 0, 0.497311,-99) );
// itree = 411
fBoostWeights.push_back(0.00832408);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.533007,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.530872,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.499007,-99) ,
2, -0.2105, 1, 0, 0.500129,-99) ,
3, 8.84402, 0, 0, 0.501341,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.464794,-99) ,
4, 0.999048, 0, 0, 0.500226,-99) );
// itree = 412
fBoostWeights.push_back(0.0310638);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.498091, 1, 1, 0.544623,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.504761,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.457989,-99) ,
9, 1.88501, 1, 0, 0.500537,-99) ,
8, 0.874401, 0, 0, 0.50504,-99) ,
NN(
NN(
0,
0,
-1, 1.5718, 0, 1, 0.508106,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.347357,-99) ,
6, -1.8572, 0, 0, 0.495657,-99) ,
6, -951.286, 1, 0, 0.500411,-99) );
// itree = 413
fBoostWeights.push_back(0.0178269);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.534523,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.511189,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.494318,-99) ,
0, 0.494281, 1, 0, 0.497413,-99) ,
3, 9.13153, 0, 0, 0.498578,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.503912,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.437453,-99) ,
8, -3.10657, 1, 0, 0.470862,-99) ,
4, 0.999524, 0, 0, 0.497114,-99) );
// itree = 414
fBoostWeights.push_back(0.0112714);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.525688,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.502787,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.481021,-99) ,
9, 3.05534, 1, 0, 0.502179,-99) ,
8, -4.54446, 1, 0, 0.503565,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.469668,-99) ,
9, 3.82918, 1, 0, 0.502153,-99) );
// itree = 415
fBoostWeights.push_back(0.0235607);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.508205,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.48908,-99) ,
4, 0.999989, 0, 0, 0.500485,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.465873,-99) ,
4, 0.999773, 0, 0, 0.499237,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.459491,-99) ,
4, 0.999524, 0, 0, 0.497163,-99) );
// itree = 416
fBoostWeights.push_back(0.0319363);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 1.88956, 1, 1, 0.543932,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.529486,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.493163,-99) ,
8, 1.81533, 0, 0, 0.494622,-99) ,
5, 0.00792338, 0, 0, 0.501362,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.357052,-99) ,
5, 0.0237713, 1, 0, 0.497738,-99) );
// itree = 417
fBoostWeights.push_back(0.0196441);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.561647, 1, 1, 0.504365,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.471506,-99) ,
3, 9.39546, 1, 0, 0.503281,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.544676,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.453612,-99) ,
8, 1.3182, 0, 0, 0.508135,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.441405,-99) ,
6, -951.286, 1, 0, 0.482199,-99) ,
9, 2.41454, 1, 0, 0.501114,-99) );
// itree = 418
fBoostWeights.push_back(0.0143574);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -0.649862, 0, 1, 0.517573,-99) ,
NN(
0,
0,
-1, 2.65786, 1, -1, 0.496198,-99) ,
7, 1.28577, 0, 0, 0.499501,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.452203,-99) ,
4, 0.999048, 0, 0, 0.498091,-99) );
// itree = 419
fBoostWeights.push_back(0.009564);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.51711,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.499902,-99) ,
8, -0.911594, 0, 0, 0.502028,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.508399,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.477495,-99) ,
7, 1.00031, 0, 0, 0.488813,-99) ,
9, 2.22554, 1, 0, 0.500448,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.469579,-99) ,
9, -2.59265, 0, 0, 0.499546,-99) );
// itree = 420
fBoostWeights.push_back(0.0276955);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -0.142747, 0, 1, 0.561951,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.503312,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.486262,-99) ,
5, 0.00145535, 0, 0, 0.498552,-99) ,
5, 0.0101874, 0, 0, 0.50369,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.365839,-99) ,
5, 0.0237713, 1, 0, 0.500221,-99) );
// itree = 421
fBoostWeights.push_back(0.0318023);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.55511,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.491474,-99) ,
8, 0.355438, 1, 0, 0.540013,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.502291,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.486671,-99) ,
9, -0.266979, 1, 0, 0.494655,-99) ,
5, 0.00787487, 0, 0, 0.500866,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.359978,-99) ,
5, 0.0236299, 1, 0, 0.497295,-99) );
// itree = 422
fBoostWeights.push_back(0.0205626);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.507489,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.492278,-99) ,
7, 0.673486, 0, 0, 0.496488,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.468568,-99) ,
7, 2.14288, 1, 0, 0.495493,-99) ,
NN(
0,
0,
-1, 2.38939, 0, -1, 0.464632,-99) ,
9, 3.05633, 1, 0, 0.493453,-99) );
// itree = 423
fBoostWeights.push_back(0.0153286);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.545715,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.494013,-99) ,
9, 2.98912, 1, 0, 0.51948,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.502802,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.475312,-99) ,
9, 1.27254, 1, 0, 0.499427,-99) ,
8, 0.604372, 0, 0, 0.500874,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.471397,-99) ,
9, 4.20343, 1, 0, 0.499887,-99) );
// itree = 424
fBoostWeights.push_back(0.0171343);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.537837,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.493458,-99) ,
9, -1.56018, 1, 0, 0.508233,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.500556,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.428515,-99) ,
9, -1.35471, 0, 0, 0.496791,-99) ,
7, -0.428573, 1, 0, 0.499899,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.476019,-99) ,
9, -2.26819, 0, 0, 0.498645,-99) );
// itree = 425
fBoostWeights.push_back(0.0141853);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.538031,-99) ,
NN(
0,
0,
-1, 3.15261, 1, -1, 0.495454,-99) ,
7, 2.1428, 0, 0, 0.497229,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.455984,-99) ,
4, 0.999048, 0, 0, 0.495983,-99) );
// itree = 426
fBoostWeights.push_back(0.0179511);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -951.286, 0, 1, 0.527378,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.49112,-99) ,
9, 4.17927, 1, 0, 0.520561,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.537074,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.498559,-99) ,
8, -1.38538, 0, 0, 0.502063,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.469969,-99) ,
9, 1.41521, 1, 0, 0.500806,-99) ,
8, -0.479071, 0, 0, 0.504382,-99) );
// itree = 427
fBoostWeights.push_back(0.0438507);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.573097,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.507614,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.439437,-99) ,
9, 2.61326, 1, 0, 0.504031,-99) ,
8, 1.90606, 0, 0, 0.507689,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.515602,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.471705,-99) ,
6, -0.700856, 0, 0, 0.505379,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.326763,-99) ,
6, -1.85715, 0, 0, 0.491758,-99) ,
6, -951.286, 1, 0, 0.499843,-99) );
// itree = 428
fBoostWeights.push_back(0.0156224);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.542752,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.524629,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.495535,-99) ,
7, -1.571, 1, 0, 0.497407,-99) ,
4, 0.999048, 1, 0, 0.498793,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.46263,-99) ,
3, 9.32353, 1, 0, 0.497704,-99) );
// itree = 429
fBoostWeights.push_back(0.0146878);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.510478,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.495553,-99) ,
0, 0.5019, 0, 0, 0.498429,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.462231,-99) ,
3, 7.57947, 1, 0, 0.497233,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.471476,-99) ,
3, 9.33743, 1, 0, 0.496442,-99) );
// itree = 430
fBoostWeights.push_back(0.0148515);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.525201,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.505309,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.494218,-99) ,
9, 0.384284, 1, 0, 0.501633,-99) ,
7, 2.14284, 0, 0, 0.502644,-99) ,
NN(
0,
0,
-1, -951.286, 0, -1, 0.475952,-99) ,
0, 0.504757, 1, 0, 0.500968,-99) );
// itree = 431
fBoostWeights.push_back(0.00971613);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.513382,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.49989,-99) ,
8, -1.05212, 0, 0, 0.502345,-99) ,
NN(
0,
0,
-1, 0.498092, 1, -1, 0.474885,-99) ,
7, 1.85714, 1, 0, 0.500678,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.478569,-99) ,
9, 3.35768, 1, 0, 0.499465,-99) );
// itree = 432
fBoostWeights.push_back(0.0176062);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.572004,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.494383,-99) ,
9, -1.95415, 1, 0, 0.514484,-99) ,
NN(
0,
0,
-1, -3.75773, 0, -1, 0.496004,-99) ,
7, -0.714167, 1, 0, 0.499758,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.459712,-99) ,
9, -2.57238, 0, 0, 0.498543,-99) );
// itree = 433
fBoostWeights.push_back(0.0334424);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.572637,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.537723,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.451118,-99) ,
9, -2.15946, 1, 0, 0.500153,-99) ,
9, -0.150886, 0, 0, 0.519972,-99) ,
NN(
NN(
0,
0,
-1, 1.42288, 0, 1, 0.506509,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.505578,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.32143,-99) ,
6, -1.85705, 0, 0, 0.491362,-99) ,
6, -951.286, 1, 0, 0.498907,-99) ,
7, -1.28554, 1, 0, 0.501105,-99) );
// itree = 434
fBoostWeights.push_back(0.0187971);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.51751,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.481943,-99) ,
9, 0.0704497, 0, 0, 0.512421,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.501749,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.48934,-99) ,
6, -951.286, 1, 0, 0.495659,-99) ,
7, 1.00007, 0, 0, 0.499368,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.467108,-99) ,
4, 0.999048, 0, 0, 0.498384,-99) );
// itree = 435
fBoostWeights.push_back(0.0174425);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.529422,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.512122,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.494244,-99) ,
4, 0.999955, 1, 0, 0.497982,-99) ,
3, 9.00889, 0, 0, 0.499044,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.46338,-99) ,
4, 0.999048, 0, 0, 0.497955,-99) );
// itree = 436
fBoostWeights.push_back(0.0121533);
fForest.push_back(
NN(
NN(
0,
0,
-1, -0.19472, 0, 1, 0.526288,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.501457,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.448227,-99) ,
7, -1.57142, 0, 0, 0.49943,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.462513,-99) ,
9, -2.50949, 0, 0, 0.498171,-99) ,
0, 0.491424, 1, 0, 0.500162,-99) );
// itree = 437
fBoostWeights.push_back(0.0154359);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.535956,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.498287,-99) ,
7, 0.143549, 0, 0, 0.518157,-99) ,
NN(
0,
0,
-1, 9.08246, 1, -1, 0.494531,-99) ,
8, 0.617997, 0, 0, 0.496268,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.453968,-99) ,
9, 4.33774, 1, 0, 0.494987,-99) );
// itree = 438
fBoostWeights.push_back(0.00818663);
fForest.push_back(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.525345,-99) ,
NN(
NN(
0,
0,
-1, 0.49809, 0, 1, 0.524488,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.500163,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.44852,-99) ,
4, 0.999773, 0, 0, 0.498403,-99) ,
4, 0.999524, 1, 0, 0.499845,-99) ,
7, 2.14285, 0, 0, 0.500917,-99) );
// itree = 439
fBoostWeights.push_back(0.0141243);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.530686,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.498928,-99) ,
8, -1.57572, 0, 0, 0.501588,-99) ,
NN(
0,
0,
-1, 0.0691512, 1, -1, 0.48802,-99) ,
9, 1.00548, 1, 0, 0.49819,-99) ,
NN(
0,
0,
-1, 0.5058, 1, -1, 0.479823,-99) ,
0, 0.503805, 1, 0, 0.496419,-99) );
// itree = 440
fBoostWeights.push_back(0.0102477);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.544904,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.499185,-99) ,
3, 8.78535, 0, 0, 0.500783,-99) ,
NN(
0,
0,
-1, -0.355773, 1, -1, 0.474508,-99) ,
4, 0.999819, 0, 0, 0.498928,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.458062,-99) ,
4, 0.999048, 0, 0, 0.497706,-99) );
// itree = 441
fBoostWeights.push_back(0.00998248);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.545929,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.54355,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.498386,-99) ,
2, -0.2105, 1, 0, 0.49999,-99) ,
4, 0.999049, 1, 0, 0.501375,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.476601,-99) ,
3, 9.25184, 1, 0, 0.500597,-99) );
// itree = 442
fBoostWeights.push_back(0.0210537);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.554722,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.495989,-99) ,
7, -2.0474, 0, 0, 0.531198,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.506626,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.461066,-99) ,
9, -2.18187, 0, 0, 0.504905,-99) ,
NN(
0,
0,
-1, 2.09658, 0, -1, 0.47635,-99) ,
9, 3.08216, 1, 0, 0.502954,-99) ,
7, -1.57122, 1, 0, 0.504726,-99) );
// itree = 443
fBoostWeights.push_back(0.0119794);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.538453,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.529664,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.497459,-99) ,
7, 2.14288, 0, 0, 0.498723,-99) ,
3, 8.78248, 0, 0, 0.500221,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.474724,-99) ,
4, 0.999524, 0, 0, 0.498881,-99) );
// itree = 444
fBoostWeights.push_back(0.0278755);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.551438,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.517303,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.466307,-99) ,
7, -1.77553, 0, 0, 0.494249,-99) ,
6, -951.287, 0, 0, 0.518546,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.505775,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.465715,-99) ,
7, -0.877504, 0, 0, 0.503506,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.529351,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.39502,-99) ,
7, -0.743497, 1, 0, 0.480481,-99) ,
9, -1.69071, 0, 0, 0.501616,-99) ,
7, -1.2857, 1, 0, 0.503323,-99) );
// itree = 445
fBoostWeights.push_back(0.023004);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.565396,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.490752,-99) ,
6, -951.286, 0, 0, 0.515512,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.503558,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.481089,-99) ,
9, 0.179503, 1, 0, 0.497576,-99) ,
8, -0.671412, 0, 0, 0.500283,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.474639,-99) ,
9, 3.35768, 1, 0, 0.498881,-99) );
// itree = 446
fBoostWeights.push_back(0.0199222);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.543398,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.516165,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.495257,-99) ,
2, 0.0326421, 0, 0, 0.500521,-99) ,
2, -0.211823, 1, 0, 0.502284,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.463684,-99) ,
3, 9.27699, 1, 0, 0.501051,-99) );
// itree = 447
fBoostWeights.push_back(0.0239523);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.542777,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.541585,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.438915,-99) ,
7, -1.7754, 0, 0, 0.497653,-99) ,
6, -951.286, 0, 0, 0.516632,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.538926,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.494086,-99) ,
4, 0.999048, 1, 0, 0.495474,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.462726,-99) ,
3, 9.10638, 1, 0, 0.494376,-99) ,
7, -1.28554, 1, 0, 0.496672,-99) );
// itree = 448
fBoostWeights.push_back(0.0245364);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.498091, 1, 1, 0.53651,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.507975,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.484491,-99) ,
7, 0.647698, 1, 0, 0.503299,-99) ,
8, -2.1187, 0, 0, 0.506186,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.539779,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.496473,-99) ,
7, -0.999806, 1, 0, 0.500253,-99) ,
NN(
0,
0,
-1, -0.139604, 0, -1, 0.453461,-99) ,
2, -0.0716018, 0, 0, 0.492824,-99) ,
9, 0.357493, 1, 0, 0.501251,-99) );
// itree = 449
fBoostWeights.push_back(0.0149182);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.552166,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.502986,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.47231,-99) ,
9, 3.58218, 1, 0, 0.501575,-99) ,
7, 2.14287, 0, 0, 0.503674,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.448034,-99) ,
4, 0.999048, 0, 0, 0.502046,-99) );
// itree = 450
fBoostWeights.push_back(0.00949788);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.51891,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.501221,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.46934,-99) ,
4, 0.999864, 0, 0, 0.499021,-99) ,
4, 0.999524, 1, 0, 0.500047,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.473281,-99) ,
3, 9.37272, 1, 0, 0.499234,-99) );
// itree = 451
fBoostWeights.push_back(0.017424);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 1.52344, 0, 1, 0.531952,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.501718,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.491,-99) ,
8, -2.58898, 0, 0, 0.496264,-99) ,
7, 1.85714, 0, 0, 0.498713,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.443696,-99) ,
4, 0.999048, 0, 0, 0.497069,-99) );
// itree = 452
fBoostWeights.push_back(0.0276656);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.545378,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.487916,-99) ,
6, -951.286, 1, 0, 0.52311,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.504948,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.485287,-99) ,
2, -0.0032833, 1, 0, 0.496101,-99) ,
8, 0.425737, 0, 0, 0.49921,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.516828,-99) ,
NN(
0,
0,
-1, 0.454026, 1, -1, 0.474042,-99) ,
0, 0.493329, 1, 0, 0.482445,-99) ,
2, 0.07151, 1, 0, 0.496694,-99) );
// itree = 453
fBoostWeights.push_back(0.00878998);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.536467,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.499688,-99) ,
3, 8.74033, 0, 0, 0.501047,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.461365,-99) ,
4, 0.999796, 0, 0, 0.499383,-99) ,
NN(
0,
0,
-1, 0.498091, 0, -1, 0.474103,-99) ,
4, 0.999524, 0, 0, 0.498052,-99) );
// itree = 454
fBoostWeights.push_back(0.0116271);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.499043, 1, 1, 0.520212,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.529671,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.499481,-99) ,
7, -1.77534, 1, 0, 0.500992,-99) ,
7, 1.28574, 0, 0, 0.504009,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.47183,-99) ,
2, -0.214346, 0, 0, 0.502666,-99) );
// itree = 455
fBoostWeights.push_back(0.0167495);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 1.85712, 0, 1, 0.506127,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.466234,-99) ,
4, 0.999728, 0, 0, 0.504244,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.461873,-99) ,
4, 0.999048, 0, 0, 0.502942,-99) );
// itree = 456
fBoostWeights.push_back(0.00990523);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.509353,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.498865,-99) ,
8, -1.14454, 0, 0, 0.501427,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.476716,-99) ,
0, 0.490063, 0, 0, 0.500509,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.504946,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.468803,-99) ,
0, 0.506253, 0, 0, 0.483374,-99) ,
0, 0.504757, 1, 0, 0.499421,-99) );
// itree = 457
fBoostWeights.push_back(0.0174293);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.52208,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.489246,-99) ,
0, 0.502852, 1, 0, 0.517179,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.479817,-99) ,
2, 0.0728659, 1, 0, 0.511933,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.553374,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.499469,-99) ,
4, 0.999048, 1, 0, 0.501786,-99) ,
NN(
0,
0,
-1, -951.286, 1, -1, 0.465361,-99) ,
9, 0.893946, 1, 0, 0.498724,-99) ,
8, -0.845409, 0, 0, 0.501595,-99) );
// itree = 458
fBoostWeights.push_back(0.0133319);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 5.81649, 0, 1, 0.505003,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.475133,-99) ,
3, 7.16313, 1, 0, 0.503611,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.469107,-99) ,
3, 9.37272, 1, 0, 0.502594,-99) );
// itree = 459
fBoostWeights.push_back(0.0164649);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 1.57148, 0, 1, 0.506464,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.474207,-99) ,
4, 0.999683, 0, 0, 0.505216,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.458983,-99) ,
4, 0.999048, 0, 0, 0.50382,-99) );
// itree = 460
fBoostWeights.push_back(0.0104255);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.551617,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.499677,-99) ,
3, 8.75156, 0, 0, 0.501603,-99) ,
NN(
0,
0,
-1, 0.496185, 0, -1, 0.473374,-99) ,
4, 0.999887, 0, 0, 0.499196,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.478491,-99) ,
4, 0.999524, 0, 0, 0.498104,-99) );
// itree = 461
fBoostWeights.push_back(0.01162);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.541417,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.496267,-99) ,
7, -2.04761, 0, 0, 0.523814,-99) ,
NN(
0,
0,
-1, 1.91156, 1, -1, 0.495642,-99) ,
7, -1.57141, 1, 0, 0.497471,-99) );
// itree = 462
fBoostWeights.push_back(0.00958684);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.544895,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.527662,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.49952,-99) ,
2, -0.202791, 1, 0, 0.50053,-99) ,
4, 0.999524, 1, 0, 0.502888,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.465756,-99) ,
3, 9.10638, 1, 0, 0.501634,-99) );
// itree = 463
fBoostWeights.push_back(0.0134122);
fForest.push_back(
NN(
NN(
0,
0,
-1, -951.286, 1, 1, 0.517043,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.515414,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.498803,-99) ,
2, 0.0307141, 0, 0, 0.503082,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.477865,-99) ,
2, -0.214062, 0, 0, 0.502102,-99) ,
0, 0.503804, 0, 0, 0.503627,-99) );
// itree = 464
fBoostWeights.push_back(0.0144843);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.54146,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.514691,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.499865,-99) ,
3, 1.42015, 1, 0, 0.505107,-99) ,
2, 0.217012, 0, 0, 0.506361,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.469417,-99) ,
3, 9.37272, 1, 0, 0.505266,-99) );
// itree = 465
fBoostWeights.push_back(0.0187924);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.539958,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.477178,-99) ,
1, -0.00204691, 0, 0, 0.515355,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.50394,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.479605,-99) ,
9, 1.58157, 1, 0, 0.502032,-99) ,
8, 0.472398, 0, 0, 0.50358,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.461374,-99) ,
4, 0.999048, 0, 0, 0.502305,-99) );
// itree = 466
fBoostWeights.push_back(0.00655901);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.514707,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.499974,-99) ,
7, 1.57148, 0, 0, 0.501551,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.468073,-99) ,
4, 0.999048, 0, 0, 0.500589,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.47346,-99) ,
9, -2.50949, 0, 0, 0.499677,-99) );
// itree = 467
fBoostWeights.push_back(0.014949);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.557434,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.49401,-99) ,
7, 0.141549, 0, 0, 0.52271,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.502254,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.482301,-99) ,
9, 0.809766, 1, 0, 0.49915,-99) ,
8, -0.18025, 0, 0, 0.501066,-99) ,
NN(
0,
0,
-1, 1.84796, 0, -1, 0.483111,-99) ,
9, 2.77661, 1, 0, 0.499635,-99) );
// itree = 468
fBoostWeights.push_back(0.0286442);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.538383,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.548859,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.45688,-99) ,
9, -0.107071, 0, 0, 0.499141,-99) ,
9, -2.11277, 1, 0, 0.516167,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.525061,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.494671,-99) ,
8, -2.26079, 0, 0, 0.498825,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.502612,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.473522,-99) ,
8, -0.208989, 0, 0, 0.48601,-99) ,
9, 0.436529, 1, 0, 0.494074,-99) ,
7, -1.28554, 1, 0, 0.496354,-99) );
// itree = 469
fBoostWeights.push_back(0.0136735);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.53775,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.543364,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.481216,-99) ,
6, -951.286, 1, 0, 0.510668,-99) ,
8, -0.590595, 0, 0, 0.518547,-99) ,
NN(
NN(
0,
0,
-1, -2.37859, 0, 1, 0.519714,-99) ,
NN(
0,
0,
-1, -1.69372, 0, -1, 0.49768,-99) ,
8, -4.37409, 1, 0, 0.499506,-99) ,
7, 1.57148, 0, 0, 0.501538,-99) );
// itree = 470
fBoostWeights.push_back(0.017643);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -0.85258, 1, 1, 0.518727,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.514738,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.497635,-99) ,
3, 4.43263, 0, 0, 0.50146,-99) ,
0, 0.49537, 1, 0, 0.503892,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.523283,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.496281,-99) ,
6, -951.286, 0, 0, 0.509727,-99) ,
NN(
0,
0,
-1, -0.713937, 0, -1, 0.475114,-99) ,
7, 0.428815, 0, 0, 0.48873,-99) ,
0, 0.493329, 0, 0, 0.501877,-99) );
// itree = 471
fBoostWeights.push_back(0.0273509);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.509576,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.477312,-99) ,
2, 0.215386, 1, 0, 0.508444,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.514032,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.391992,-99) ,
7, -0.589612, 1, 0, 0.489378,-99) ,
9, -1.58113, 0, 0, 0.505888,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.470695,-99) ,
7, -1.85713, 0, 0, 0.504679,-99) );
// itree = 472
fBoostWeights.push_back(0.0217452);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.509582,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.497383,-99) ,
6, -951.286, 1, 0, 0.503562,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.517271,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.462674,-99) ,
1, -0.00111496, 1, 0, 0.484529,-99) ,
7, 1.57148, 1, 0, 0.501654,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.518812,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.483861,-99) ,
7, -0.0654518, 0, 0, 0.498534,-99) ,
NN(
0,
0,
-1, 0.139707, 1, -1, 0.465658,-99) ,
9, 0.0371492, 1, 0, 0.484214,-99) ,
2, 0.0717303, 1, 0, 0.49907,-99) );
// itree = 473
fBoostWeights.push_back(0.0115487);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 2.14283, 0, 1, 0.503294,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.471643,-99) ,
4, 0.999683, 0, 0, 0.502024,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.445011,-99) ,
4, 0.999048, 0, 0, 0.500366,-99) );
// itree = 474
fBoostWeights.push_back(0.0296473);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.00400652, 1, 1, 0.540642,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.506504,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.488688,-99) ,
6, -951.286, 0, 0, 0.497633,-99) ,
5, 0.0089997, 0, 0, 0.502141,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.383732,-99) ,
5, 0.0236249, 1, 0, 0.499189,-99) );
// itree = 475
fBoostWeights.push_back(0.0150416);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.539392,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.520294,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.496191,-99) ,
8, 1.58535, 0, 0, 0.497703,-99) ,
4, 0.999048, 1, 0, 0.499054,-99) ,
NN(
0,
0,
-1, -951.286, 0, -1, 0.469514,-99) ,
7, 1.85714, 1, 0, 0.497178,-99) );
// itree = 476
fBoostWeights.push_back(0.0161052);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -0.0716018, 1, 1, 0.506531,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.474546,-99) ,
7, -1.57124, 0, 0, 0.505269,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.468841,-99) ,
9, -2.52271, 0, 0, 0.504088,-99) );
// itree = 477
fBoostWeights.push_back(0.0192451);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.505141,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.466262,-99) ,
9, -2.09324, 0, 0, 0.502986,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.473331,-99) ,
7, -1.85714, 0, 0, 0.501989,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.506694,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.48287,-99) ,
0, 0.491923, 1, 0, 0.490238,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.456946,-99) ,
0, 0.490154, 0, 0, 0.483656,-99) ,
0, 0.494281, 0, 0, 0.498665,-99) );
// itree = 478
fBoostWeights.push_back(0.00802772);
fForest.push_back(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.536036,-99) ,
NN(
NN(
0,
0,
-1, -4.62519, 1, 1, 0.50175,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.473898,-99) ,
9, 4.15532, 1, 0, 0.500821,-99) ,
7, 2.14284, 0, 0, 0.502348,-99) );
// itree = 479
fBoostWeights.push_back(0.0211804);
fForest.push_back(
NN(
NN(
0,
0,
-1, 2.31813, 0, 1, 0.526187,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.54065,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.492811,-99) ,
4, 0.999048, 1, 0, 0.494345,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.455822,-99) ,
3, 9.38661, 1, 0, 0.49315,-99) ,
8, 1.33504, 0, 0, 0.495532,-99) );
// itree = 480
fBoostWeights.push_back(0.017203);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 2.14285, 0, 1, 0.506329,-99) ,
NN(
0,
0,
-1, -0.469166, 1, -1, 0.47476,-99) ,
4, 0.999864, 0, 0, 0.504113,-99) ,
NN(
0,
0,
-1, 0.498092, 0, -1, 0.474232,-99) ,
4, 0.999524, 0, 0, 0.502554,-99) );
// itree = 481
fBoostWeights.push_back(0.00774729);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.524599,-99) ,
NN(
0,
0,
-1, -2.28134, 0, -1, 0.497853,-99) ,
7, -1.85713, 1, 0, 0.498831,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.47223,-99) ,
0, 0.505709, 1, 0, 0.49786,-99) );
// itree = 482
fBoostWeights.push_back(0.0216345);
fForest.push_back(
NN(
NN(
0,
0,
-1, -0.929804, 0, 1, 0.532954,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.557238,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.497514,-99) ,
8, 1.62971, 0, 0, 0.501442,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.500129,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.344051,-99) ,
6, -1.85712, 0, 0, 0.48783,-99) ,
6, -951.286, 1, 0, 0.494628,-99) ,
7, -1.57125, 1, 0, 0.497158,-99) );
// itree = 483
fBoostWeights.push_back(0.0299082);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.56018,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.503943,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.44194,-99) ,
9, 2.34039, 1, 0, 0.499678,-99) ,
8, 1.60585, 0, 0, 0.50366,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.561266,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.496768,-99) ,
7, 1.57179, 0, 0, 0.50285,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.356697,-99) ,
6, -1.85715, 0, 0, 0.491783,-99) ,
6, -951.286, 1, 0, 0.497813,-99) );
// itree = 484
fBoostWeights.push_back(0.0174615);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.999524, 1, 1, 0.507098,-99) ,
NN(
0,
0,
-1, 0.534235, 0, -1, 0.491289,-99) ,
9, 0.460091, 1, 0, 0.501541,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.457219,-99) ,
3, 9.32353, 1, 0, 0.500197,-99) );
// itree = 485
fBoostWeights.push_back(0.00956551);
fForest.push_back(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.521767,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.500226,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.473255,-99) ,
9, 3.24907, 1, 0, 0.498519,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.445344,-99) ,
9, -2.21141, 0, 0, 0.496287,-99) ,
7, -1.85713, 1, 0, 0.497246,-99) );
// itree = 486
fBoostWeights.push_back(0.0159371);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -1.54728, 0, 1, 0.509021,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.505098,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.493302,-99) ,
7, 1.00007, 0, 0, 0.495946,-99) ,
0, 0.500675, 0, 0, 0.498985,-99) ,
NN(
0,
0,
-1, -0.142705, 1, -1, 0.477113,-99) ,
0, 0.504757, 1, 0, 0.497604,-99) );
// itree = 487
fBoostWeights.push_back(0.0136198);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.539543,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.52158,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.469556,-99) ,
3, 1.78677, 0, 0, 0.499545,-99) ,
9, 2.83231, 1, 0, 0.512579,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.537408,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.499067,-99) ,
8, -0.628572, 0, 0, 0.500287,-99) ,
NN(
0,
0,
-1, -0.0922477, 0, -1, 0.477061,-99) ,
9, 1.53437, 1, 0, 0.498462,-99) ,
8, 0.398814, 0, 0, 0.500119,-99) );
// itree = 488
fBoostWeights.push_back(0.00919883);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.527229,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.501212,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.456066,-99) ,
3, 7.10923, 1, 0, 0.499518,-99) ,
3, 8.75156, 0, 0, 0.500573,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.468003,-99) ,
4, 0.999048, 0, 0, 0.499588,-99) );
// itree = 489
fBoostWeights.push_back(0.00958732);
fForest.push_back(
NN(
NN(
0,
0,
-1, -1.9794, 0, 1, 0.520775,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.501018,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.469565,-99) ,
7, 1.9116, 1, 0, 0.499133,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.473539,-99) ,
9, 4.06459, 1, 0, 0.498146,-99) ,
7, -1.57125, 1, 0, 0.499602,-99) );
// itree = 490
fBoostWeights.push_back(0.020782);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.550586,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.517297,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.492524,-99) ,
8, -4.34575, 1, 0, 0.494388,-99) ,
4, 0.999048, 1, 0, 0.496078,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.464078,-99) ,
3, 9.07001, 1, 0, 0.494988,-99) );
// itree = 491
fBoostWeights.push_back(0.0128433);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 2.18124, 0, 1, 0.519192,-99) ,
NN(
0,
0,
-1, 3.66705, 1, -1, 0.496095,-99) ,
7, 1.57151, 0, 0, 0.498533,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.46457,-99) ,
4, 0.999048, 0, 0, 0.497508,-99) );
// itree = 492
fBoostWeights.push_back(0.0109196);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.490789, 1, 1, 0.515134,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.490098,-99) ,
0, 0.489519, 0, 0, 0.510252,-99) ,
NN(
NN(
0,
0,
-1, 3.2731, 1, -1, 0.497885,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.507793,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.46827,-99) ,
7, 2.11568, 0, 0, 0.484922,-99) ,
7, 1.57146, 1, 0, 0.496578,-99) ,
0, 0.493329, 1, 0, 0.498455,-99) );
// itree = 493
fBoostWeights.push_back(0.0159334);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.528523,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.524446,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.497758,-99) ,
1, 0.00718515, 0, 0, 0.499691,-99) ,
4, 0.999524, 1, 0, 0.501652,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.504015,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.482558,-99) ,
9, 2.22664, 1, 0, 0.49564,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.46185,-99) ,
2, -0.0716622, 0, 0, 0.490197,-99) ,
9, 0.759337, 1, 0, 0.49832,-99) );
// itree = 494
fBoostWeights.push_back(0.0146698);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.527547,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.504558,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.482856,-99) ,
9, 1.57247, 1, 0, 0.502355,-99) ,
8, 0.954896, 0, 0, 0.503471,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.480312,-99) ,
9, 3.84063, 1, 0, 0.502505,-99) );
// itree = 495
fBoostWeights.push_back(0.0165617);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.501492, 0, 1, 0.506697,-99) ,
NN(
0,
0,
-1, -951.286, 1, -1, 0.48666,-99) ,
0, 0.503804, 1, 0, 0.504786,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.461038,-99) ,
4, 0.999048, 0, 0, 0.503473,-99) );
// itree = 496
fBoostWeights.push_back(0.00895933);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.544266,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.49922,-99) ,
9, 2.42226, 0, 0, 0.500518,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.504626,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.464082,-99) ,
3, 2.26363, 0, 0, 0.483725,-99) ,
9, 2.81353, 1, 0, 0.499166,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.468908,-99) ,
3, 9.08221, 1, 0, 0.498134,-99) );
// itree = 497
fBoostWeights.push_back(0.0148356);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -1.67388, 0, 1, 0.505535,-99) ,
NN(
0,
0,
-1, 1.70241, 0, -1, 0.480121,-99) ,
9, 2.81353, 1, 0, 0.503707,-99) ,
NN(
0,
0,
-1, 1.55061, 0, -1, 0.480159,-99) ,
7, 1.85719, 1, 0, 0.502198,-99) );
// itree = 498
fBoostWeights.push_back(0.0156444);
fForest.push_back(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.524294,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.520302,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.508154,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.493723,-99) ,
8, -3.9435, 1, 0, 0.495884,-99) ,
7, 2.14281, 0, 0, 0.496921,-99) ,
0, 0.505709, 0, 0, 0.498006,-99) );
// itree = 499
fBoostWeights.push_back(0.00967251);
fForest.push_back(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.53365,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.500673,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.453246,-99) ,
9, -2.22812, 0, 0, 0.498553,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.470186,-99) ,
9, 4.15632, 1, 0, 0.497572,-99) ,
7, -1.85696, 1, 0, 0.498976,-99) );
// itree = 500
fBoostWeights.push_back(0.0171917);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -1.32563, 0, 1, 0.5044,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.472324,-99) ,
4, 0.999048, 0, 0, 0.503425,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.527614,-99) ,
NN(
0,
0,
-1, -1.61245, 0, -1, 0.448279,-99) ,
9, -2.11064, 1, 0, 0.484379,-99) ,
7, -1.2857, 0, 0, 0.501562,-99) );
// itree = 501
fBoostWeights.push_back(0.01929);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.512991,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.499782,-99) ,
0, 0.500403, 0, 0, 0.508582,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.506533,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.490528,-99) ,
0, 0.493601, 1, 0, 0.494732,-99) ,
0, 0.499043, 0, 0, 0.500055,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.503806,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.461014,-99) ,
0, 0.506117, 0, 0, 0.480265,-99) ,
0, 0.504757, 1, 0, 0.498777,-99) );
// itree = 502
fBoostWeights.push_back(0.0150018);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.538434,-99) ,
NN(
0,
0,
-1, 0.491424, 0, -1, 0.496815,-99) ,
7, 2.14286, 0, 0, 0.498653,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.520958,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.491611,-99) ,
0, 0.506026, 0, 0, 0.49518,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.450511,-99) ,
7, 1.28582, 1, 0, 0.488831,-99) ,
0, 0.500947, 1, 0, 0.496145,-99) );
// itree = 503
fBoostWeights.push_back(0.0140977);
fForest.push_back(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.547572,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.529563,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.529899,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.496553,-99) ,
3, 9.00889, 0, 0, 0.497688,-99) ,
4, 0.999048, 1, 0, 0.49871,-99) ,
7, 2.14285, 0, 0, 0.500891,-99) );
// itree = 504
fBoostWeights.push_back(0.017417);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.505103,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.466298,-99) ,
9, -2.5712, 0, 0, 0.503841,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.475012,-99) ,
9, 3.09326, 1, 0, 0.502093,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.452268,-99) ,
7, 2.1428, 1, 0, 0.500219,-99) );
// itree = 505
fBoostWeights.push_back(0.0207494);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.999951, 0, 1, 0.516229,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.504654,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.49052,-99) ,
7, -0.142853, 1, 0, 0.496279,-99) ,
0, 0.496186, 1, 0, 0.499598,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.516325,-99) ,
NN(
0,
0,
-1, 0.42867, 0, -1, 0.4833,-99) ,
2, -0.0717387, 1, 0, 0.490619,-99) ,
0, 0.494281, 0, 0, 0.497944,-99) );
// itree = 506
fBoostWeights.push_back(0.00699008);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.533911,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.499993,-99) ,
2, -0.209911, 1, 0, 0.501123,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.458958,-99) ,
4, 0.999751, 0, 0, 0.499909,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.47436,-99) ,
4, 0.999524, 0, 0, 0.498587,-99) );
// itree = 507
fBoostWeights.push_back(0.0176537);
fForest.push_back(
NN(
NN(
0,
0,
-1, 4.09845, 1, 1, 0.529857,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.509176,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.497449,-99) ,
6, -951.286, 0, 0, 0.503295,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.458135,-99) ,
7, 2.14288, 1, 0, 0.5016,-99) ,
8, 1.33504, 0, 0, 0.503623,-99) );
// itree = 508
fBoostWeights.push_back(0.0210046);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.535279,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.494834,-99) ,
8, -1.94384, 0, 0, 0.498229,-99) ,
NN(
0,
0,
-1, -0.158284, 0, -1, 0.488025,-99) ,
9, 0.514112, 1, 0, 0.494579,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.468195,-99) ,
9, -2.21706, 0, 0, 0.493089,-99) );
// itree = 509
fBoostWeights.push_back(0.0394465);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.940743, 0, 1, 0.51748,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.511228,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.368541,-99) ,
6, -1.85733, 0, 0, 0.50046,-99) ,
6, -951.286, 1, 0, 0.509227,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.451215,-99) ,
4, 0.999048, 0, 0, 0.50755,-99) );
// itree = 510
fBoostWeights.push_back(0.0252939);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -0.0712183, 1, 1, 0.504332,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.511275,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.478061,-99) ,
8, -0.692645, 0, 0, 0.488032,-99) ,
7, -0.428446, 0, 0, 0.501033,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.54432,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.488893,-99) ,
8, -4.17435, 0, 0, 0.508616,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.397125,-99) ,
7, -0.701173, 1, 0, 0.480634,-99) ,
9, -1.55321, 0, 0, 0.497953,-99) );
// itree = 511
fBoostWeights.push_back(0.017936);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.536784,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.511153,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.493169,-99) ,
0, 0.492376, 1, 0, 0.494918,-99) ,
4, 0.999048, 1, 0, 0.496157,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.46615,-99) ,
3, 9.12028, 1, 0, 0.495176,-99) );
// itree = 512
fBoostWeights.push_back(0.0155078);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 1.85713, 0, 1, 0.508745,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.503782,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.492049,-99) ,
6, -951.286, 1, 0, 0.497573,-99) ,
8, -1.14454, 0, 0, 0.500448,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.456925,-99) ,
4, 0.999048, 0, 0, 0.499186,-99) );
// itree = 513
fBoostWeights.push_back(0.0231514);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.548194,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.496692,-99) ,
9, -0.958746, 0, 0, 0.515617,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.503927,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.490468,-99) ,
9, -0.578152, 1, 0, 0.495377,-99) ,
7, -1.28551, 1, 0, 0.497487,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.510633,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.48199,-99) ,
0, 0.490517, 1, 0, 0.487248,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.46366,-99) ,
3, 4.57903, 1, 0, 0.482743,-99) ,
0, 0.495233, 0, 0, 0.493938,-99) );
// itree = 514
fBoostWeights.push_back(0.0160372);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.494366, 1, 1, 0.502837,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.503242,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.466079,-99) ,
0, 0.505994, 0, 0, 0.480101,-99) ,
0, 0.504213, 1, 0, 0.500716,-99) ,
NN(
0,
0,
-1, 0.492512, 1, -1, 0.469527,-99) ,
0, 0.493329, 0, 0, 0.496655,-99) );
// itree = 515
fBoostWeights.push_back(0.0206387);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.523358,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.498712,-99) ,
9, 2.66103, 1, 0, 0.514749,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.506121,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.477676,-99) ,
8, 0.697015, 0, 0, 0.489064,-99) ,
0, 0.496186, 0, 0, 0.506502,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.530419,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.494798,-99) ,
7, -1.84322, 1, 0, 0.49624,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.441724,-99) ,
7, 1.85713, 1, 0, 0.493862,-99) ,
8, -1.14454, 0, 0, 0.497059,-99) );
// itree = 516
fBoostWeights.push_back(0.029734);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 2.23882, 1, 1, 0.519573,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.511745,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.491978,-99) ,
7, -0.714148, 1, 0, 0.496437,-99) ,
2, -0.068022, 1, 0, 0.499668,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.525586,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.446369,-99) ,
6, -0.429494, 0, 0, 0.495847,-99) ,
NN(
0,
0,
-1, -0.142731, 0, -1, 0.4714,-99) ,
6, -951.286, 0, 0, 0.483858,-99) ,
3, 4.54783, 1, 0, 0.496441,-99) );
// itree = 517
fBoostWeights.push_back(0.0103346);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.523219,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.500877,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.485066,-99) ,
7, -0.999989, 0, 0, 0.498394,-99) ,
8, 2.12087, 0, 0, 0.499625,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.45896,-99) ,
4, 0.999048, 0, 0, 0.498434,-99) );
// itree = 518
fBoostWeights.push_back(0.0126912);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -0.743926, 0, 1, 0.503907,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.468992,-99) ,
2, -0.132825, 0, 0, 0.50227,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.466311,-99) ,
2, -0.214437, 0, 0, 0.500798,-99) );
// itree = 519
fBoostWeights.push_back(0.00947737);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.537553,-99) ,
NN(
0,
0,
-1, 0.999819, 0, -1, 0.49763,-99) ,
4, 0.999048, 1, 0, 0.4988,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.502834,-99) ,
NN(
0,
0,
-1, -0.142294, 0, -1, 0.477366,-99) ,
2, -0.0684755, 1, 0, 0.484095,-99) ,
0, 0.492377, 0, 0, 0.497396,-99) );
// itree = 520
fBoostWeights.push_back(0.0108204);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.535049,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.499434,-99) ,
8, 0.998191, 0, 0, 0.500733,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.46582,-99) ,
9, 3.50899, 1, 0, 0.499188,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.506684,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.472605,-99) ,
0, 0.49809, 0, 0, 0.490443,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.453193,-99) ,
7, 2.31975, 1, 0, 0.480558,-99) ,
7, 1.5715, 1, 0, 0.497306,-99) );
// itree = 521
fBoostWeights.push_back(0.00736037);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.543889,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.500412,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.470686,-99) ,
9, 4.19061, 1, 0, 0.499375,-99) ,
4, 0.999048, 1, 0, 0.500711,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.46501,-99) ,
3, 9.25184, 1, 0, 0.499622,-99) );
// itree = 522
fBoostWeights.push_back(0.0214901);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.499042, 1, 1, 0.524443,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.517624,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.464732,-99) ,
9, -1.36818, 1, 0, 0.488277,-99) ,
7, -0.142901, 0, 0, 0.510011,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.50238,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.481243,-99) ,
7, 1.28571, 1, 0, 0.49911,-99) ,
NN(
0,
0,
-1, 0.00307367, 0, -1, 0.480035,-99) ,
0, 0.5019, 1, 0, 0.495645,-99) ,
2, -0.0714192, 1, 0, 0.498118,-99) );
// itree = 523
fBoostWeights.push_back(0.0171249);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.54402,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.482193,-99) ,
7, -0.33976, 0, 0, 0.518591,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.50119,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.475253,-99) ,
9, 0.362159, 1, 0, 0.499014,-99) ,
8, -1.70961, 0, 0, 0.500981,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.504217,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.474386,-99) ,
7, -0.142699, 0, 0, 0.495448,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.46122,-99) ,
8, -1.01473, 0, 0, 0.489549,-99) ,
9, 0.969131, 1, 0, 0.49803,-99) );
// itree = 524
fBoostWeights.push_back(0.0142558);
fForest.push_back(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.534384,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.522339,-99) ,
NN(
0,
0,
-1, -0.142851, 0, -1, 0.494843,-99) ,
8, 2.09564, 0, 0, 0.496204,-99) ,
2, 0.214255, 0, 0, 0.497711,-99) );
// itree = 525
fBoostWeights.push_back(0.0309557);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.520194,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.476512,-99) ,
3, 4.68186, 1, 0, 0.507285,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.52093,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.489531,-99) ,
2, 0.00729097, 0, 0, 0.495987,-99) ,
2, 0.030612, 0, 0, 0.498967,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.470702,-99) ,
2, -0.214257, 0, 0, 0.497794,-99) );
// itree = 526
fBoostWeights.push_back(0.0354856);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.528443,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.499174,-99) ,
7, 1.04082, 1, 0, 0.510773,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.556774,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.424301,-99) ,
9, -0.441241, 0, 0, 0.479002,-99) ,
8, -2.8378, 0, 0, 0.504987,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.524263,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.491755,-99) ,
8, -3.26627, 0, 0, 0.502259,-99) ,
NN(
0,
0,
-1, -0.0723801, 0, -1, 0.482055,-99) ,
9, -0.240556, 1, 0, 0.495548,-99) ,
7, 0.428571, 0, 0, 0.499304,-99) );
// itree = 527
fBoostWeights.push_back(0.011933);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.568573,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.49067,-99) ,
3, 1.6006, 0, 0, 0.52335,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.496371,-99) ,
3, 3.21457, 1, 0, 0.514516,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.532741,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.498825,-99) ,
8, -0.359461, 0, 0, 0.500681,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.4591,-99) ,
9, 2.21615, 1, 0, 0.499422,-99) ,
8, 0.734616, 0, 0, 0.500858,-99) );
// itree = 528
fBoostWeights.push_back(0.0125212);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 2.84095, 1, 1, 0.520014,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.502465,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.474255,-99) ,
9, 1.71826, 1, 0, 0.500663,-99) ,
8, 0.536301, 0, 0, 0.50212,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.461052,-99) ,
9, 4.20333, 1, 0, 0.500785,-99) );
// itree = 529
fBoostWeights.push_back(0.0135023);
fForest.push_back(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.531586,-99) ,
NN(
NN(
0,
0,
-1, -951.286, 0, 1, 0.505261,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.482327,-99) ,
0, 0.490472, 0, 0, 0.504273,-99) ,
8, 2.71126, 0, 0, 0.505285,-99) );
// itree = 530
fBoostWeights.push_back(0.0215908);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.555981,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.534933,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.488777,-99) ,
0, 0.500947, 0, 0, 0.501284,-99) ,
1, 0.00373063, 0, 0, 0.51242,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.516765,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.49539,-99) ,
8, 0.5783, 0, 0, 0.497535,-99) ,
NN(
0,
0,
-1, 0.498091, 0, -1, 0.47881,-99) ,
2, 0.0722928, 1, 0, 0.494774,-99) ,
7, 1.28577, 0, 0, 0.497518,-99) );
// itree = 531
fBoostWeights.push_back(0.0104206);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.529458,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.501083,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.49083,-99) ,
7, -0.714137, 0, 0, 0.498705,-99) ,
8, 0.508793, 0, 0, 0.499714,-99) ,
NN(
0,
0,
-1, 1.92674, 0, -1, 0.478811,-99) ,
9, 2.77661, 1, 0, 0.49805,-99) );
// itree = 532
fBoostWeights.push_back(0.0303457);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.517675,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.492535,-99) ,
4, 0.999996, 0, 0, 0.503733,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.514158,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.430894,-99) ,
9, -0.160748, 1, 0, 0.486311,-99) ,
4, 0.999909, 0, 0, 0.501553,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.465754,-99) ,
4, 0.999048, 0, 0, 0.500485,-99) );
// itree = 533
fBoostWeights.push_back(0.0173894);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.539392,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.517559,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.462717,-99) ,
8, -4.34407, 1, 0, 0.490749,-99) ,
7, -1.09584, 1, 0, 0.513822,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.521582,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.499401,-99) ,
7, -0.428366, 1, 0, 0.502729,-99) ,
NN(
0,
0,
-1, 0.499996, 1, -1, 0.481577,-99) ,
7, -0.999854, 0, 0, 0.500549,-99) ,
8, -4.03342, 1, 0, 0.502193,-99) );
// itree = 534
fBoostWeights.push_back(0.0131839);
fForest.push_back(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.523397,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.510213,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.499089,-99) ,
0, 0.499995, 0, 0, 0.502855,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.452473,-99) ,
9, -2.21141, 0, 0, 0.500676,-99) ,
7, -1.85713, 1, 0, 0.501524,-99) );
// itree = 535
fBoostWeights.push_back(0.0183664);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.544437,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.498861,-99) ,
9, -2.00146, 1, 0, 0.518207,-99) ,
NN(
0,
0,
-1, 0.7144, 0, 1, 0.505025,-99) ,
7, -0.999808, 1, 0, 0.507089,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.538882,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.495144,-99) ,
0, 0.504757, 0, 0, 0.506462,-99) ,
NN(
0,
0,
-1, -2.59102, 1, -1, 0.484353,-99) ,
7, 0.14286, 0, 0, 0.495298,-99) ,
0, 0.500947, 1, 0, 0.504069,-99) );
// itree = 536
fBoostWeights.push_back(0.0194555);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.558926, 0, 1, 0.527932,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.5141,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.485235,-99) ,
7, 1.47615, 1, 0, 0.498837,-99) ,
0, 0.497138, 1, 0, 0.510906,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.535387,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.495834,-99) ,
7, -1.44895, 1, 0, 0.498058,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.47377,-99) ,
7, -1.85714, 0, 0, 0.496994,-99) ,
7, 0.999969, 0, 0, 0.50006,-99) );
// itree = 537
fBoostWeights.push_back(0.0201117);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.545351,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.541739,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.473623,-99) ,
6, -951.286, 1, 0, 0.505171,-99) ,
8, -0.802906, 0, 0, 0.517866,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.559835,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.502224,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.467803,-99) ,
0, 0.505709, 1, 0, 0.500995,-99) ,
4, 0.999048, 1, 0, 0.502809,-99) ,
7, 1.28571, 0, 0, 0.505155,-99) );
// itree = 538
fBoostWeights.push_back(0.0152065);
fForest.push_back(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.517932,-99) ,
NN(
NN(
0,
0,
-1, -1.90783, 0, 1, 0.505477,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.504707,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.481933,-99) ,
8, -0.643084, 0, 0, 0.493996,-99) ,
9, 0.630301, 1, 0, 0.502318,-99) ,
8, 1.83089, 0, 0, 0.503186,-99) );
// itree = 539
fBoostWeights.push_back(0.014853);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -1.68739, 0, 1, 0.517608,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.50589,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.495034,-99) ,
0, 0.494145, 1, 0, 0.497093,-99) ,
0, 0.504757, 0, 0, 0.498421,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.452327,-99) ,
3, 8.91541, 1, 0, 0.496788,-99) );
// itree = 540
fBoostWeights.push_back(0.0108084);
fForest.push_back(
NN(
NN(
0,
0,
-1, 0.499995, 1, 1, 0.52196,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.500287,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.470987,-99) ,
7, -1.97936, 0, 0, 0.499336,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.473073,-99) ,
9, 3.52123, 1, 0, 0.498236,-99) ,
7, 1.28577, 0, 0, 0.501985,-99) );
// itree = 541
fBoostWeights.push_back(0.0190895);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 9.14066, 0, 1, 0.507184,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.471339,-99) ,
4, 0.999796, 0, 0, 0.505683,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.518592,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.447486,-99) ,
9, -0.890614, 1, 0, 0.482035,-99) ,
4, 0.999524, 0, 0, 0.504447,-99) );
// itree = 542
fBoostWeights.push_back(0.0149245);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.503303,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.495856,-99) ,
6, -951.286, 0, 0, 0.499593,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.461991,-99) ,
7, 2.14277, 1, 0, 0.498366,-99) ,
NN(
0,
0,
-1, 2.35067, 0, -1, 0.468456,-99) ,
9, 2.47498, 1, 0, 0.49543,-99) );
// itree = 543
fBoostWeights.push_back(0.0252083);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.574558,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.496682,-99) ,
9, -0.833993, 0, 0, 0.523263,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.484546,-99) ,
7, -1.93849, 0, 0, 0.511912,-99) ,
NN(
NN(
0,
0,
-1, 1.41479, 0, 1, 0.504291,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.506369,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.334323,-99) ,
6, -1.85725, 0, 0, 0.493513,-99) ,
6, -951.286, 1, 0, 0.498909,-99) ,
7, -1.28544, 1, 0, 0.500259,-99) );
// itree = 544
fBoostWeights.push_back(0.0368487);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.510064,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.491701,-99) ,
9, 0.597513, 1, 0, 0.502168,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.42383,-99) ,
9, -1.11861, 0, 0, 0.497711,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.528263,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.482247,-99) ,
8, -4.0347, 0, 0, 0.503032,-99) ,
NN(
0,
0,
-1, -0.0783631, 0, -1, 0.46937,-99) ,
9, -1.16235, 1, 0, 0.487113,-99) ,
7, -0.142851, 0, 0, 0.493462,-99) );
// itree = 545
fBoostWeights.push_back(0.0241514);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -3.55017, 0, 1, 0.512632,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.508006,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.47722,-99) ,
6, -951.286, 0, 0, 0.488939,-99) ,
9, -1.13217, 1, 0, 0.501438,-99) ,
NN(
0,
0,
-1, -1.10561, 0, -1, 0.489779,-99) ,
7, -0.142735, 1, 0, 0.494528,-99) );
// itree = 546
fBoostWeights.push_back(0.0183857);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.551234,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.494695,-99) ,
7, 2.29256, 1, 0, 0.526846,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.500519,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.491212,-99) ,
0, 0.500947, 0, 0, 0.493623,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.469372,-99) ,
9, 3.82918, 1, 0, 0.492684,-99) ,
7, 1.85713, 0, 0, 0.495002,-99) );
// itree = 547
fBoostWeights.push_back(0.0192974);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.999524, 1, 1, 0.50649,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.501322,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.465305,-99) ,
7, -0.142536, 0, 0, 0.486567,-99) ,
0, 0.492694, 0, 0, 0.50362,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.506229,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.483122,-99) ,
7, -0.142554, 0, 0, 0.49537,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.459987,-99) ,
7, 1.28587, 1, 0, 0.490389,-99) ,
0, 0.500947, 1, 0, 0.500242,-99) );
// itree = 548
fBoostWeights.push_back(0.00846931);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.545739,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.495126,-99) ,
7, 2.29255, 1, 0, 0.524132,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.518597,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.499884,-99) ,
4, 0.999524, 1, 0, 0.500775,-99) ,
NN(
0,
0,
-1, -0.455327, 0, -1, 0.483696,-99) ,
0, 0.492376, 0, 0, 0.499141,-99) ,
7, 1.85717, 0, 0, 0.500858,-99) );
// itree = 549
fBoostWeights.push_back(0.0249973);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.529168,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.491987,-99) ,
3, 4.50494, 1, 0, 0.516061,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.525386,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.496409,-99) ,
8, 2.00472, 0, 0, 0.498169,-99) ,
2, 0.0715723, 0, 0, 0.500956,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.542844,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.491642,-99) ,
8, -4.22167, 0, 0, 0.510769,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.400458,-99) ,
7, -0.703459, 1, 0, 0.48332,-99) ,
9, -1.56113, 0, 0, 0.498318,-99) );
// itree = 550
fBoostWeights.push_back(0.0267162);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.542127,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.478123,-99) ,
4, 0.999977, 0, 0, 0.521486,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.511215,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.494622,-99) ,
6, -951.286, 1, 0, 0.503131,-99) ,
7, 1.28579, 0, 0, 0.505925,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.502143,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.44465,-99) ,
8, -3.17646, 1, 0, 0.473213,-99) ,
4, 0.999524, 0, 0, 0.504251,-99) );
// itree = 551
fBoostWeights.push_back(0.0206473);
fForest.push_back(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.532244,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.510044,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.492723,-99) ,
8, -1.73059, 0, 0, 0.497416,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.4678,-99) ,
9, 3.24397, 1, 0, 0.495764,-99) ,
7, 2.14284, 0, 0, 0.497275,-99) );
// itree = 552
fBoostWeights.push_back(0.0347895);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -0.872416, 0, 1, 0.521263,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.513703,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.478617,-99) ,
8, -1.91478, 0, 0, 0.501502,-99) ,
8, -2.97727, 1, 0, 0.507786,-99) ,
NN(
NN(
0,
0,
-1, 1.28594, 0, 1, 0.50834,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.379222,-99) ,
6, -1.85705, 0, 0, 0.498593,-99) ,
6, -951.286, 1, 0, 0.503271,-99) );
// itree = 553
fBoostWeights.push_back(0.0193462);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.550239,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.484494,-99) ,
6, -951.286, 0, 0, 0.517455,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.529327,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.498182,-99) ,
4, 0.999524, 1, 0, 0.499848,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.518378,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.482997,-99) ,
8, -0.83085, 0, 0, 0.490706,-99) ,
0, 0.499995, 1, 0, 0.496794,-99) ,
7, 1.85713, 0, 0, 0.498204,-99) );
// itree = 554
fBoostWeights.push_back(0.0225758);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.552714,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.503923,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.485246,-99) ,
9, 2.10817, 1, 0, 0.501609,-99) ,
7, -1.85688, 1, 0, 0.503594,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.511591,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.476852,-99) ,
7, 0.143166, 0, 0, 0.49883,-99) ,
NN(
0,
0,
-1, -0.0146879, 1, -1, 0.47308,-99) ,
8, -3.01661, 0, 0, 0.489768,-99) ,
0, 0.499995, 1, 0, 0.49902,-99) );
// itree = 555
fBoostWeights.push_back(0.0177814);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -0.072978, 1, 1, 0.523655,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.550582,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.496264,-99) ,
3, 8.84402, 0, 0, 0.498308,-99) ,
0, 0.493329, 1, 0, 0.501726,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.473729,-99) ,
4, 0.999524, 0, 0, 0.500285,-99) );
// itree = 556
fBoostWeights.push_back(0.0176903);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.517359,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.498881,-99) ,
8, -2.5033, 0, 0, 0.505091,-99) ,
NN(
0,
0,
-1, 0.143089, 0, -1, 0.486883,-99) ,
9, 1.05997, 1, 0, 0.503259,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.507152,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.479368,-99) ,
8, 0.746509, 0, 0, 0.495858,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.45945,-99) ,
2, -0.0681797, 0, 0, 0.489664,-99) ,
9, 1.74667, 1, 0, 0.501103,-99) );
// itree = 557
fBoostWeights.push_back(0.00892318);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.555567,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.499472,-99) ,
6, -951.286, 0, 0, 0.526754,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.54034,-99) ,
NN(
0,
0,
-1, 0.999728, 0, -1, 0.498432,-99) ,
4, 0.999048, 1, 0, 0.499749,-99) ,
7, 1.85718, 0, 0, 0.501594,-99) );
// itree = 558
fBoostWeights.push_back(0.0228045);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.529514,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.494266,-99) ,
3, 4.37719, 1, 0, 0.517981,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.512946,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.494216,-99) ,
2, 0.0222869, 0, 0, 0.501029,-99) ,
2, -0.0515344, 1, 0, 0.503947,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.47144,-99) ,
2, -0.214725, 0, 0, 0.502647,-99) );
// itree = 559
fBoostWeights.push_back(0.0178792);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -0.00332356, 1, 1, 0.505545,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.455798,-99) ,
0, 0.505709, 1, 0, 0.503956,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.511218,-99) ,
NN(
0,
0,
-1, -0.260109, 1, -1, 0.474744,-99) ,
7, 0.7143, 0, 0, 0.485924,-99) ,
2, 0.0714933, 1, 0, 0.501209,-99) );
// itree = 560
fBoostWeights.push_back(0.0141091);
fForest.push_back(
NN(
NN(
0,
0,
-1, -0.82101, 0, 1, 0.514971,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.51212,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.498277,-99) ,
8, -0.597588, 0, 0, 0.500922,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.508705,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.484995,-99) ,
9, -1.07853, 1, 0, 0.490013,-99) ,
0, 0.495233, 0, 0, 0.498276,-99) ,
7, -1.28554, 1, 0, 0.500028,-99) );
// itree = 561
fBoostWeights.push_back(0.0106611);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -4.26665, 1, 1, 0.503737,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.471866,-99) ,
9, -2.56061, 0, 0, 0.502747,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.467386,-99) ,
1, 0.0138019, 1, 0, 0.501695,-99) );
// itree = 562
fBoostWeights.push_back(0.016313);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.5384,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.503924,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.480235,-99) ,
3, 9.33163, 1, 0, 0.503126,-99) ,
0, 0.505709, 0, 0, 0.504536,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.514088,-99) ,
NN(
0,
0,
-1, 3.01893, 1, -1, 0.470605,-99) ,
8, 2.31949, 0, 0, 0.48542,-99) ,
9, 2.09511, 1, 0, 0.502099,-99) );
// itree = 563
fBoostWeights.push_back(0.0138755);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.563903,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.495627,-99) ,
7, 0.427353, 0, 0, 0.522141,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.512562,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.496424,-99) ,
8, -4.26036, 1, 0, 0.497839,-99) ,
3, 0.539768, 1, 0, 0.499714,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.469156,-99) ,
3, 9.25993, 1, 0, 0.498738,-99) );
// itree = 564
fBoostWeights.push_back(0.0171921);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.528349,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.49898,-99) ,
7, 0.427842, 1, 0, 0.517188,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.506793,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.496466,-99) ,
0, 0.501295, 0, 0, 0.499793,-99) ,
0, 0.495551, 1, 0, 0.501577,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.51416,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.505562,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.473111,-99) ,
7, 1.00016, 0, 0, 0.480321,-99) ,
2, -0.0684755, 1, 0, 0.488066,-99) ,
0, 0.494281, 0, 0, 0.499096,-99) );
// itree = 565
fBoostWeights.push_back(0.0166128);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -0.0714015, 1, 1, 0.511855,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.506796,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.495764,-99) ,
6, -951.286, 0, 0, 0.501258,-99) ,
0, 0.497455, 1, 0, 0.505183,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.500742,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.474401,-99) ,
6, -951.286, 1, 0, 0.488316,-99) ,
0, 0.492376, 0, 0, 0.503553,-99) );
// itree = 566
fBoostWeights.push_back(0.0150744);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.50361,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.455354,-99) ,
7, -1.57127, 0, 0, 0.501747,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.470742,-99) ,
9, -2.50949, 0, 0, 0.500685,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.503551,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.478225,-99) ,
7, 0.550948, 1, 0, 0.490952,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.458272,-99) ,
7, -0.428605, 0, 0, 0.480688,-99) ,
0, 0.492376, 0, 0, 0.498756,-99) );
// itree = 567
fBoostWeights.push_back(0.00814907);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.526149,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.500162,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.46676,-99) ,
2, -0.13242, 0, 0, 0.498568,-99) ,
2, -0.214037, 1, 0, 0.499832,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.474195,-99) ,
9, 3.39176, 1, 0, 0.498475,-99) );
// itree = 568
fBoostWeights.push_back(0.0127028);
fForest.push_back(
NN(
NN(
0,
0,
-1, -1.91141, 0, 1, 0.527975,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.537042,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.498068,-99) ,
7, 2.12928, 0, 0, 0.499868,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.4586,-99) ,
2, 0.21418, 1, 0, 0.498414,-99) ,
7, -1.57125, 1, 0, 0.50029,-99) );
// itree = 569
fBoostWeights.push_back(0.0252293);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.508026,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.49234,-99) ,
7, -0.714285, 0, 0, 0.505941,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.514643,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.41354,-99) ,
7, -0.680101, 1, 0, 0.48938,-99) ,
9, -1.54265, 0, 0, 0.503428,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.501663,-99) ,
NN(
0,
0,
-1, 0.49714, 1, -1, 0.476476,-99) ,
2, 0.20714, 0, 0, 0.48323,-99) ,
2, 0.0711262, 1, 0, 0.500372,-99) );
// itree = 570
fBoostWeights.push_back(0.0160112);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.429043, 0, 1, 0.523664,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.503387,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.492177,-99) ,
0, 0.49809, 0, 0, 0.497915,-99) ,
3, 0.543175, 1, 0, 0.499971,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.45955,-99) ,
3, 9.33163, 1, 0, 0.498755,-99) );
// itree = 571
fBoostWeights.push_back(0.0211867);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 2.50729, 1, 1, 0.527494,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.521595,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.489763,-99) ,
7, -0.904686, 1, 0, 0.500934,-99) ,
7, 0.142968, 0, 0, 0.516467,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.518351,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.495709,-99) ,
7, 1.27621, 0, 0, 0.498428,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.449408,-99) ,
9, 1.28978, 1, 0, 0.496658,-99) ,
8, -0.739558, 0, 0, 0.500788,-99) );
// itree = 572
fBoostWeights.push_back(0.0125413);
fForest.push_back(
NN(
NN(
0,
0,
-1, -1.97937, 0, 1, 0.521203,-99) ,
NN(
0,
0,
-1, 1.10255, 1, -1, 0.494734,-99) ,
7, -1.57123, 1, 0, 0.496401,-99) );
// itree = 573
fBoostWeights.push_back(0.0235439);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -0.922157, 1, 1, 0.533125,-99) ,
NN(
0,
0,
-1, 1.85712, 1, -1, 0.496461,-99) ,
5, 0.00676617, 0, 0, 0.503112,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.378247,-99) ,
5, 0.0236981, 1, 0, 0.499945,-99) );
// itree = 574
fBoostWeights.push_back(0.0162829);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.546219,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.525511,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.49883,-99) ,
8, -2.20993, 0, 0, 0.502156,-99) ,
4, 0.999048, 1, 0, 0.504018,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.515007,-99) ,
NN(
0,
0,
-1, 2.62036, 1, -1, 0.488551,-99) ,
8, 1.64954, 0, 0, 0.49303,-99) ,
9, 0.420636, 1, 0, 0.500106,-99) );
// itree = 575
fBoostWeights.push_back(0.0294139);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.55271,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.51531,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.438601,-99) ,
7, 0.145983, 1, 0, 0.502676,-99) ,
8, -3.02891, 0, 0, 0.509089,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.50075,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.469667,-99) ,
0, 0.491424, 0, 0, 0.498855,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.514552,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.444269,-99) ,
7, 0.428566, 0, 0, 0.485882,-99) ,
2, -0.0716018, 0, 0, 0.49673,-99) ,
9, -0.625753, 1, 0, 0.501452,-99) );
// itree = 576
fBoostWeights.push_back(0.019611);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.545548, 1, 1, 0.507008,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.468351,-99) ,
3, 9.38081, 1, 0, 0.505663,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.500997,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.481052,-99) ,
0, 0.49936, 1, 0, 0.490265,-99) ,
NN(
0,
0,
-1, 2.13073, 1, -1, 0.470426,-99) ,
0, 0.495233, 0, 0, 0.485325,-99) ,
9, 0.954811, 1, 0, 0.500407,-99) );
// itree = 577
fBoostWeights.push_back(0.0100186);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.539137,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.528223,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.499286,-99) ,
7, 2.14272, 0, 0, 0.500443,-99) ,
3, 9.12912, 0, 0, 0.501616,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.455903,-99) ,
4, 0.999524, 0, 0, 0.499324,-99) );
// itree = 578
fBoostWeights.push_back(0.0219569);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -1.79441, 0, 1, 0.518805,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.506131,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.476738,-99) ,
7, -0.919088, 0, 0, 0.502438,-99) ,
8, -3.89663, 1, 0, 0.50596,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.504499,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.48814,-99) ,
0, 0.499043, 0, 0, 0.4953,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.46901,-99) ,
2, 0.0700881, 1, 0, 0.491365,-99) ,
9, 0.71673, 1, 0, 0.501597,-99) );
// itree = 579
fBoostWeights.push_back(0.0114064);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -951.286, 0, 1, 0.531878,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.501586,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.484289,-99) ,
4, 0.999864, 0, 0, 0.500023,-99) ,
7, 1.85713, 0, 0, 0.502166,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.465574,-99) ,
4, 0.999048, 0, 0, 0.501066,-99) );
// itree = 580
fBoostWeights.push_back(0.0180945);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.546384,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.508268,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.494049,-99) ,
2, -0.0315868, 1, 0, 0.497577,-99) ,
3, 9.13835, 0, 0, 0.499115,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.467341,-99) ,
4, 0.999524, 0, 0, 0.497499,-99) );
// itree = 581
fBoostWeights.push_back(0.00889754);
fForest.push_back(
NN(
NN(
0,
0,
-1, -0.178062, 0, 1, 0.502289,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.502414,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.476916,-99) ,
8, 1.07937, 0, 0, 0.491708,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.453576,-99) ,
0, 0.5019, 1, 0, 0.483785,-99) ,
9, 1.99143, 1, 0, 0.499814,-99) );
// itree = 582
fBoostWeights.push_back(0.0108191);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 1.85718, 0, 1, 0.502177,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.501446,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.470671,-99) ,
7, 0.714203, 1, 0, 0.492414,-99) ,
0, 0.499859, 1, 0, 0.499271,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.500167,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.458929,-99) ,
6, -951.286, 0, 0, 0.479527,-99) ,
0, 0.504757, 1, 0, 0.498038,-99) );
// itree = 583
fBoostWeights.push_back(0.0153282);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.999524, 1, 1, 0.505289,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.472992,-99) ,
2, 0.214083, 1, 0, 0.504251,-99) ,
NN(
0,
0,
-1, -0.998795, 0, -1, 0.485191,-99) ,
0, 0.501899, 1, 0, 0.500629,-99) );
// itree = 584
fBoostWeights.push_back(0.0117507);
fForest.push_back(
NN(
NN(
0,
0,
-1, 0.505256, 1, 1, 0.517426,-99) ,
NN(
0,
0,
-1, -2.37309, 0, -1, 0.495428,-99) ,
0, 0.503804, 0, 0, 0.497657,-99) );
// itree = 585
fBoostWeights.push_back(0.0127353);
fForest.push_back(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.530295,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.524778,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.497623,-99) ,
7, 2.07483, 0, 0, 0.499034,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.453059,-99) ,
9, -2.21141, 0, 0, 0.497048,-99) ,
7, -1.85713, 1, 0, 0.49832,-99) );
// itree = 586
fBoostWeights.push_back(0.0104032);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.518167,-99) ,
NN(
0,
0,
-1, -1.78369, 0, -1, 0.496555,-99) ,
8, -4.65877, 1, 0, 0.497585,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.469105,-99) ,
9, 3.88864, 1, 0, 0.496462,-99) );
// itree = 587
fBoostWeights.push_back(0.0211797);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.500053, 0, 1, 0.517593,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.508174,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.485184,-99) ,
0, 0.501666, 0, 0, 0.502473,-99) ,
0, 0.500675, 1, 0, 0.507592,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.506793,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.493715,-99) ,
6, -951.286, 0, 0, 0.50026,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.510186,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.465885,-99) ,
0, 0.493602, 1, 0, 0.482262,-99) ,
2, 0.0712424, 1, 0, 0.49768,-99) ,
0, 0.499042, 0, 0, 0.501868,-99) );
// itree = 588
fBoostWeights.push_back(0.0163337);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.535895,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.487381,-99) ,
6, -951.286, 0, 0, 0.511293,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.50374,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.491983,-99) ,
6, -951.286, 1, 0, 0.497958,-99) ,
7, 1.57142, 0, 0, 0.499324,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.477167,-99) ,
4, 0.999048, 0, 0, 0.498661,-99) );
// itree = 589
fBoostWeights.push_back(0.0152119);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.536181,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.493879,-99) ,
9, -1.92255, 1, 0, 0.513202,-99) ,
NN(
0,
0,
-1, 3.28316, 1, -1, 0.498421,-99) ,
7, -0.999839, 1, 0, 0.500758,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.500806,-99) ,
NN(
0,
0,
-1, 0.501582, 1, -1, 0.479753,-99) ,
2, 0.0705527, 0, 0, 0.483544,-99) ,
0, 0.500947, 1, 0, 0.496359,-99) );
// itree = 590
fBoostWeights.push_back(0.0185064);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.505562,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.445516,-99) ,
9, -2.32688, 0, 0, 0.503262,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.477562,-99) ,
7, -1.85697, 0, 0, 0.502266,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.500903,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.473272,-99) ,
8, 1.19602, 0, 0, 0.489583,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.463458,-99) ,
0, 0.495235, 0, 0, 0.482902,-99) ,
9, 2.09511, 1, 0, 0.499845,-99) );
// itree = 591
fBoostWeights.push_back(0.0202212);
fForest.push_back(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.527641,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.50775,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.493347,-99) ,
7, -0.00663092, 1, 0, 0.499376,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.409655,-99) ,
9, -2.38109, 0, 0, 0.496876,-99) ,
7, -1.85713, 1, 0, 0.498022,-99) );
// itree = 592
fBoostWeights.push_back(0.0225862);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.52243,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.477246,-99) ,
9, -2.53871, 0, 0, 0.513627,-99) ,
NN(
0,
0,
-1, 0.501899, 1, -1, 0.49209,-99) ,
8, -3.33462, 1, 0, 0.503506,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.50383,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.479786,-99) ,
8, -2.88453, 0, 0, 0.499591,-99) ,
NN(
0,
0,
-1, -0.142393, 1, -1, 0.486754,-99) ,
7, 0.387764, 0, 0, 0.494395,-99) ,
7, -0.428564, 1, 0, 0.497196,-99) );
// itree = 593
fBoostWeights.push_back(0.0170303);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.535697,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.517935,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.496053,-99) ,
9, 3.21442, 1, 0, 0.510419,-99) ,
7, -0.99998, 1, 0, 0.513822,-99) ,
NN(
NN(
0,
0,
-1, 1.00012, 0, 1, 0.511022,-99) ,
NN(
0,
0,
-1, 1.85726, 1, -1, 0.494493,-99) ,
1, -0.00348913, 1, 0, 0.497828,-99) ,
8, -0.651605, 0, 0, 0.501002,-99) );
// itree = 594
fBoostWeights.push_back(0.0140024);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.999524, 1, 1, 0.506845,-99) ,
NN(
0,
0,
-1, 0.462793, 0, -1, 0.489205,-99) ,
9, 1.72654, 1, 0, 0.504029,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.502221,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.487097,-99) ,
4, 0.999977, 0, 0, 0.497737,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.475083,-99) ,
4, 0.999524, 0, 0, 0.496448,-99) ,
0, 0.49809, 0, 0, 0.500344,-99) );
// itree = 595
fBoostWeights.push_back(0.015469);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.527414,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.548227,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.485713,-99) ,
8, 1.52644, 0, 0, 0.504855,-99) ,
6, -951.286, 0, 0, 0.513252,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.538586,-99) ,
NN(
0,
0,
-1, -2.25857, 0, -1, 0.497413,-99) ,
7, -1.85688, 1, 0, 0.498981,-99) ,
8, -0.405191, 0, 0, 0.501459,-99) );
// itree = 596
fBoostWeights.push_back(0.0337416);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -951.286, 1, 1, 0.51342,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.51541,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.481198,-99) ,
6, -951.286, 0, 0, 0.49455,-99) ,
7, -0.142873, 0, 0, 0.508602,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.517252,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.478392,-99) ,
9, -1.99638, 0, 0, 0.500763,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.445034,-99) ,
7, -0.292917, 1, 0, 0.491246,-99) ,
9, -1.21725, 0, 0, 0.504721,-99) );
// itree = 597
fBoostWeights.push_back(0.0215782);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.554726,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.505642,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.49131,-99) ,
8, -1.82291, 0, 0, 0.49658,-99) ,
3, 9.09389, 0, 0, 0.498474,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.457115,-99) ,
4, 0.999524, 0, 0, 0.496414,-99) );
// itree = 598
fBoostWeights.push_back(0.0135377);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.54013,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.503764,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.481478,-99) ,
3, 6.63483, 1, 0, 0.502455,-99) ,
2, -0.209432, 1, 0, 0.504026,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.472145,-99) ,
3, 9.25184, 1, 0, 0.503062,-99) );
// itree = 599
fBoostWeights.push_back(0.024793);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.529316,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.51211,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.493856,-99) ,
9, -1.4441, 1, 0, 0.50201,-99) ,
7, -0.278795, 0, 0, 0.50527,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.519522,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.485869,-99) ,
2, -0.0715367, 0, 0, 0.509679,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.524244,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.489285,-99) ,
3, 0.555202, 1, 0, 0.492647,-99) ,
3, 4.72918, 0, 0, 0.49596,-99) ,
7, -0.142742, 1, 0, 0.499736,-99) );
// itree = 600
fBoostWeights.push_back(0.0243459);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.514754,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.49457,-99) ,
6, -951.286, 1, 0, 0.504565,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.513894,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.488437,-99) ,
8, -4.58716, 1, 0, 0.492207,-99) ,
7, -0.305952, 0, 0, 0.500117,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.44927,-99) ,
7, 2.14289, 1, 0, 0.49827,-99) );
// itree = 601
fBoostWeights.push_back(0.00878633);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.543461,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.498521,-99) ,
6, -951.286, 0, 0, 0.520254,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.50042,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.471968,-99) ,
9, 3.17219, 1, 0, 0.498751,-99) ,
7, 1.85713, 0, 0, 0.500191,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.461072,-99) ,
4, 0.999048, 0, 0, 0.499058,-99) );
// itree = 602
fBoostWeights.push_back(0.0202038);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.508603,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.495979,-99) ,
4, 0.999977, 0, 0, 0.505237,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.503137,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.449366,-99) ,
7, -0.316998, 1, 0, 0.493713,-99) ,
9, -1.22685, 0, 0, 0.502791,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.453568,-99) ,
4, 0.999524, 0, 0, 0.500402,-99) );
// itree = 603
fBoostWeights.push_back(0.0147275);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.536055,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.500694,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.468742,-99) ,
0, 0.490474, 0, 0, 0.499429,-99) ,
8, -1.36412, 0, 0, 0.50117,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.529792,-99) ,
NN(
0,
0,
-1, 0.500948, 1, -1, 0.483803,-99) ,
7, -0.714119, 1, 0, 0.489697,-99) ,
9, 0.926524, 1, 0, 0.498115,-99) );
// itree = 604
fBoostWeights.push_back(0.0260056);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.516103,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.495997,-99) ,
9, -0.181073, 1, 0, 0.507543,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.500425,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.453035,-99) ,
8, -2.84754, 0, 0, 0.492227,-99) ,
7, 0.428682, 1, 0, 0.500517,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.527745,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.492238,-99) ,
8, -4.26243, 0, 0, 0.505504,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.415644,-99) ,
7, -0.724648, 1, 0, 0.4838,-99) ,
9, -1.6015, 0, 0, 0.49811,-99) );
// itree = 605
fBoostWeights.push_back(0.0288698);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.546672,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.54532,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.492029,-99) ,
7, 1.85723, 0, 0, 0.500619,-99) ,
7, -0.99982, 1, 0, 0.506712,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.52756,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.496033,-99) ,
7, 0.141337, 0, 0, 0.510546,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.504796,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.478064,-99) ,
2, -0.00353391, 1, 0, 0.492652,-99) ,
2, 0.071273, 0, 0, 0.495393,-99) ,
8, -1.33695, 0, 0, 0.498553,-99) );
// itree = 606
fBoostWeights.push_back(0.0125676);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.508322,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.496421,-99) ,
2, -0.0714185, 1, 0, 0.498417,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.469553,-99) ,
7, -1.57142, 0, 0, 0.497232,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.471469,-99) ,
9, -2.47158, 0, 0, 0.496296,-99) );
// itree = 607
fBoostWeights.push_back(0.0149414);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -1.97941, 0, 1, 0.517149,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.521344,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.495961,-99) ,
8, 2.16823, 0, 0, 0.497207,-99) ,
7, -1.57125, 1, 0, 0.498489,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.504661,-99) ,
NN(
0,
0,
-1, -0.141607, 1, -1, 0.465833,-99) ,
0, 0.505981, 0, 0, 0.47865,-99) ,
0, 0.503804, 1, 0, 0.496591,-99) );
// itree = 608
fBoostWeights.push_back(0.00759678);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.548256,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.499598,-99) ,
4, 0.999048, 1, 0, 0.50106,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.471944,-99) ,
3, 9.06192, 1, 0, 0.500044,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.465237,-99) ,
9, 4.21549, 1, 0, 0.498909,-99) );
// itree = 609
fBoostWeights.push_back(0.0285688);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.511058,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.488139,-99) ,
7, -0.346825, 0, 0, 0.503087,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.501229,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.478857,-99) ,
6, -951.286, 1, 0, 0.490229,-99) ,
7, 0.714372, 1, 0, 0.498534,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.513129,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.483008,-99) ,
9, -2.4699, 0, 0, 0.504398,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.385316,-99) ,
7, -0.558187, 1, 0, 0.484076,-99) ,
9, -1.55321, 0, 0, 0.496343,-99) );
// itree = 610
fBoostWeights.push_back(0.0199403);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.550609,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.496837,-99) ,
8, -3.20737, 0, 0, 0.51311,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.500401,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.467131,-99) ,
4, 0.999524, 0, 0, 0.499101,-99) ,
9, -0.718667, 1, 0, 0.502331,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.540386,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.488407,-99) ,
8, -4.01997, 0, 0, 0.503522,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.394112,-99) ,
7, -0.520789, 1, 0, 0.485437,-99) ,
9, -1.51059, 0, 0, 0.499611,-99) );
// itree = 611
fBoostWeights.push_back(0.0200832);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.537614,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.498994,-99) ,
9, 1.21239, 1, 0, 0.508969,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.52273,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.492157,-99) ,
4, 0.999048, 1, 0, 0.493376,-99) ,
8, -1.32664, 0, 0, 0.497077,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.468853,-99) ,
9, 3.48998, 1, 0, 0.49565,-99) );
// itree = 612
fBoostWeights.push_back(0.0147445);
fForest.push_back(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.525074,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.508714,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.495917,-99) ,
7, -0.305951, 1, 0, 0.500584,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.474339,-99) ,
2, -0.214037, 0, 0, 0.499491,-99) ,
7, 2.14286, 0, 0, 0.500558,-99) );
// itree = 613
fBoostWeights.push_back(0.00742579);
fForest.push_back(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.528834,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.500965,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.470639,-99) ,
3, 7.60472, 1, 0, 0.499946,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.470657,-99) ,
3, 9.37272, 1, 0, 0.499052,-99) ,
8, 2.77752, 0, 0, 0.500145,-99) );
// itree = 614
fBoostWeights.push_back(0.01173);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.539226,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.493924,-99) ,
0, 0.49809, 0, 0, 0.518304,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.52166,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.498737,-99) ,
8, -4.51442, 1, 0, 0.500326,-99) ,
NN(
0,
0,
-1, 1.7676, 0, -1, 0.474597,-99) ,
9, 2.61733, 1, 0, 0.498216,-99) ,
7, 1.85713, 0, 0, 0.49959,-99) );
// itree = 615
fBoostWeights.push_back(0.0148814);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.529617,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.504272,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.480899,-99) ,
9, 1.55677, 1, 0, 0.501815,-99) ,
8, 1.01284, 0, 0, 0.503201,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.480579,-99) ,
9, 4.15532, 1, 0, 0.502428,-99) );
// itree = 616
fBoostWeights.push_back(0.0228236);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.505632,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.487924,-99) ,
9, 0.420636, 1, 0, 0.499557,-99) ,
NN(
0,
0,
-1, 4.53173, 1, -1, 0.477058,-99) ,
0, 0.502852, 1, 0, 0.496414,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.435816,-99) ,
1, 0.0143116, 1, 0, 0.494785,-99) );
// itree = 617
fBoostWeights.push_back(0.0128722);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.999524, 1, 1, 0.503727,-99) ,
NN(
0,
0,
-1, 0.494283, 0, -1, 0.489174,-99) ,
3, 4.59838, 1, 0, 0.500813,-99) ,
NN(
0,
0,
-1, 2.29255, 1, -1, 0.474759,-99) ,
7, 1.8572, 1, 0, 0.499143,-99) );
// itree = 618
fBoostWeights.push_back(0.0169959);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.504391,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.494528,-99) ,
0, 0.499043, 1, 0, 0.500257,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.503785,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.409233,-99) ,
7, -0.470247, 1, 0, 0.487308,-99) ,
9, -1.42635, 0, 0, 0.49798,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.451795,-99) ,
3, 9.33163, 1, 0, 0.496654,-99) );
// itree = 619
fBoostWeights.push_back(0.0192725);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.550773,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.490358,-99) ,
8, -3.21073, 0, 0, 0.508076,-99) ,
NN(
0,
0,
-1, 0.999524, 0, -1, 0.498394,-99) ,
9, -0.734791, 1, 0, 0.500581,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.523517,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.498454,-99) ,
8, -4.32481, 0, 0, 0.509819,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.422371,-99) ,
7, -0.670204, 1, 0, 0.48792,-99) ,
9, -1.51201, 0, 0, 0.498565,-99) );
// itree = 620
fBoostWeights.push_back(0.0162214);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.544024,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.518102,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.48857,-99) ,
7, 1.93882, 1, 0, 0.50707,-99) ,
1, -0.00386971, 1, 0, 0.513949,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.521382,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.500963,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.473591,-99) ,
9, -1.57245, 0, 0, 0.496711,-99) ,
7, -1.77533, 1, 0, 0.497961,-99) ,
7, 1.28577, 0, 0, 0.500453,-99) );
// itree = 621
fBoostWeights.push_back(0.0241334);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.50347,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.483087,-99) ,
2, 0.0709465, 1, 0, 0.500619,-99) ,
NN(
0,
0,
-1, 0.493011, 1, -1, 0.486553,-99) ,
0, 0.494281, 0, 0, 0.498083,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.541386,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.483657,-99) ,
9, 0.330831, 1, 0, 0.491795,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.501398,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.439118,-99) ,
8, -2.92766, 1, 0, 0.463104,-99) ,
8, -2.43534, 0, 0, 0.484137,-99) ,
7, 0.714273, 1, 0, 0.493988,-99) );
// itree = 622
fBoostWeights.push_back(0.0112308);
fForest.push_back(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.519898,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.524384,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.497208,-99) ,
8, -4.70419, 1, 0, 0.498442,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.466824,-99) ,
9, 2.70955, 1, 0, 0.497259,-99) ,
8, 2.07703, 0, 0, 0.498377,-99) );
// itree = 623
fBoostWeights.push_back(0.0224631);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.534558,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.532007,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.444783,-99) ,
7, -1.69366, 0, 0, 0.491627,-99) ,
8, -4.12735, 1, 0, 0.510044,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.502173,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.483298,-99) ,
7, -0.469163, 0, 0, 0.499531,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.511137,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.39133,-99) ,
7, -0.55216, 1, 0, 0.478602,-99) ,
9, -1.52103, 0, 0, 0.497176,-99) ,
7, -1.28551, 1, 0, 0.498519,-99) );
// itree = 624
fBoostWeights.push_back(0.0177926);
fForest.push_back(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.525529,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.519914,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.507078,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.492163,-99) ,
2, 0.0306365, 0, 0, 0.496081,-99) ,
2, -0.214257, 1, 0, 0.497135,-99) ,
7, 2.14288, 0, 0, 0.498305,-99) );
// itree = 625
fBoostWeights.push_back(0.00993453);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 2.7177, 1, 1, 0.526341,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.501499,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.489787,-99) ,
9, -1.64151, 0, 0, 0.49974,-99) ,
8, 0.556939, 0, 0, 0.501169,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.479652,-99) ,
9, 3.39176, 1, 0, 0.499985,-99) );
// itree = 626
fBoostWeights.push_back(0.0145922);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.51206,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.498143,-99) ,
3, 4.95429, 0, 0, 0.500185,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.508502,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.483283,-99) ,
2, -0.0716933, 1, 0, 0.488239,-99) ,
0, 0.500947, 1, 0, 0.497173,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.459743,-99) ,
3, 9.37272, 1, 0, 0.496092,-99) );
// itree = 627
fBoostWeights.push_back(0.01059);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -1.05616, 0, 1, 0.502766,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.456281,-99) ,
9, -2.21141, 0, 0, 0.5008,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.472261,-99) ,
7, -1.85683, 0, 0, 0.499821,-99) );
// itree = 628
fBoostWeights.push_back(0.0180361);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.347191, 1, 1, 0.5083,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.487285,-99) ,
7, -1.28554, 0, 0, 0.506185,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.529075,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.489314,-99) ,
3, 1.56487, 0, 0, 0.513254,-99) ,
NN(
0,
0,
-1, 1.19275, 1, -1, 0.492487,-99) ,
8, 0.375626, 0, 0, 0.494945,-99) ,
0, 0.497138, 1, 0, 0.499449,-99) );
// itree = 629
fBoostWeights.push_back(0.0244253);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.53039,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.489698,-99) ,
9, 2.9857, 1, 0, 0.515395,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.506123,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.445523,-99) ,
3, 2.71679, 1, 0, 0.483467,-99) ,
7, -0.142824, 0, 0, 0.505204,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.530594,-99) ,
NN(
0,
0,
-1, -1.61484, 0, -1, 0.492107,-99) ,
8, -4.76061, 1, 0, 0.493957,-99) ,
8, -0.940716, 0, 0, 0.496478,-99) );
// itree = 630
fBoostWeights.push_back(0.0133754);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.51379,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.499815,-99) ,
0, 0.499043, 0, 0, 0.505203,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.481575,-99) ,
0, 0.504756, 1, 0, 0.503682,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.501259,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.470393,-99) ,
7, 0.00694863, 0, 0, 0.499167,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.42342,-99) ,
9, -1.13346, 0, 0, 0.495249,-99) ,
7, -0.142708, 1, 0, 0.498689,-99) );
// itree = 631
fBoostWeights.push_back(0.0226962);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.559218,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.51318,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.493497,-99) ,
1, -0.00486399, 1, 0, 0.496026,-99) ,
4, 0.999048, 1, 0, 0.498725,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.505536,-99) ,
NN(
0,
0,
-1, 0.500947, 1, -1, 0.483202,-99) ,
8, 1.63893, 0, 0, 0.487115,-99) ,
9, 0.496443, 1, 0, 0.494809,-99) );
// itree = 632
fBoostWeights.push_back(0.0182825);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.508109,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.486589,-99) ,
9, 3.08085, 1, 0, 0.506768,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.482175,-99) ,
7, 2.14278, 1, 0, 0.505813,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.482334,-99) ,
0, 0.505709, 1, 0, 0.504922,-99) );
// itree = 633
fBoostWeights.push_back(0.0143561);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.534328,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.479943,-99) ,
4, 0.999977, 0, 0, 0.516295,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.50093,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.47486,-99) ,
7, 1.136, 1, 0, 0.498642,-99) ,
7, 1.57139, 0, 0, 0.500453,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.466496,-99) ,
4, 0.999524, 0, 0, 0.498737,-99) );
// itree = 634
fBoostWeights.push_back(0.0136654);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -951.286, 0, 1, 0.529364,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.485356,-99) ,
0, 0.499996, 1, 0, 0.515842,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.514778,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.498115,-99) ,
8, -0.767075, 0, 0, 0.500715,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.478351,-99) ,
9, 3.50693, 1, 0, 0.499677,-99) ,
7, 1.5714, 0, 0, 0.501374,-99) );
// itree = 635
fBoostWeights.push_back(0.0235604);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.559106,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.49888,-99) ,
7, -0.18921, 0, 0, 0.529927,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.504207,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.443115,-99) ,
9, 0.0533873, 1, 0, 0.500908,-99) ,
8, -2.22713, 0, 0, 0.504045,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.51494,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.484995,-99) ,
9, 1.7083, 1, 0, 0.50344,-99) ,
NN(
0,
0,
-1, 0.918243, 0, -1, 0.484283,-99) ,
7, 0.714363, 0, 0, 0.494093,-99) ,
9, 0.329206, 1, 0, 0.500308,-99) );
// itree = 636
fBoostWeights.push_back(0.022878);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.428686, 1, 1, 0.515993,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.506003,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.470352,-99) ,
2, 0.0706786, 1, 0, 0.501054,-99) ,
0, 0.497138, 1, 0, 0.507177,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.531737,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.503355,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.487526,-99) ,
4, 0.999955, 1, 0, 0.491442,-99) ,
4, 0.999048, 1, 0, 0.493111,-99) ,
9, 0.460091, 0, 0, 0.498087,-99) );
// itree = 637
fBoostWeights.push_back(0.015375);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.546838,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.496948,-99) ,
3, 8.78248, 0, 0, 0.498774,-99) ,
NN(
0,
0,
-1, -2.98326, 1, -1, 0.468974,-99) ,
4, 0.999841, 0, 0, 0.497018,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.464809,-99) ,
4, 0.999524, 0, 0, 0.495376,-99) );
// itree = 638
fBoostWeights.push_back(0.0260709);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.526228,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.45681,-99) ,
7, 0.211505, 1, 0, 0.513119,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.51361,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.495708,-99) ,
0, 0.503805, 0, 0, 0.497612,-99) ,
9, -0.774017, 1, 0, 0.501056,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.512877,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.487369,-99) ,
9, -2.10323, 1, 0, 0.50202,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.433151,-99) ,
7, -0.702464, 1, 0, 0.48497,-99) ,
9, -1.55321, 0, 0, 0.498582,-99) );
// itree = 639
fBoostWeights.push_back(0.014236);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.535227,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.499159,-99) ,
2, -0.0230599, 1, 0, 0.506603,-99) ,
NN(
0,
0,
-1, -0.0683526, 0, -1, 0.495573,-99) ,
3, 2.31242, 1, 0, 0.501551,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.466134,-99) ,
3, 9.38081, 1, 0, 0.500537,-99) );
// itree = 640
fBoostWeights.push_back(0.0131461);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -0.482959, 1, 1, 0.504743,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.464392,-99) ,
7, -1.57142, 0, 0, 0.503218,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.479609,-99) ,
9, -2.33914, 0, 0, 0.502136,-99) );
// itree = 641
fBoostWeights.push_back(0.0105515);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.533689,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.513121,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.499245,-99) ,
7, 0.999961, 0, 0, 0.502276,-99) ,
4, 0.999048, 1, 0, 0.503189,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.462432,-99) ,
3, 9.39546, 1, 0, 0.502036,-99) );
// itree = 642
fBoostWeights.push_back(0.0180957);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 8.84402, 0, 1, 0.505134,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.483298,-99) ,
4, 0.999524, 0, 0, 0.504157,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.51751,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.494223,-99) ,
0, 0.496186, 0, 0, 0.510207,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.408779,-99) ,
7, -0.497298, 1, 0, 0.493832,-99) ,
9, -1.49436, 0, 0, 0.502461,-99) );
// itree = 643
fBoostWeights.push_back(0.0109433);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.499993, 1, 1, 0.521508,-99) ,
NN(
0,
0,
-1, 0.999728, 0, -1, 0.497919,-99) ,
7, 1.57142, 0, 0, 0.500377,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.448455,-99) ,
4, 0.999048, 0, 0, 0.498881,-99) );
// itree = 644
fBoostWeights.push_back(0.0153656);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.524514,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.502326,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.476267,-99) ,
9, -1.52046, 0, 0, 0.49869,-99) ,
8, -4.71179, 1, 0, 0.499894,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.507425,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.48964,-99) ,
0, 0.49904, 0, 0, 0.497583,-99) ,
NN(
0,
0,
-1, 0.498091, 1, -1, 0.469306,-99) ,
7, 0.714492, 1, 0, 0.484327,-99) ,
9, 2.24517, 1, 0, 0.498127,-99) );
// itree = 645
fBoostWeights.push_back(0.00782554);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 9.13548, 0, 1, 0.501799,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.474093,-99) ,
4, 0.999796, 0, 0, 0.500634,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.47592,-99) ,
4, 0.999524, 0, 0, 0.499356,-99) );
// itree = 646
fBoostWeights.push_back(0.0122577);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.512546,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.49906,-99) ,
7, 1.28578, 0, 0, 0.501074,-99) ,
NN(
0,
0,
-1, -0.471094, 1, -1, 0.472377,-99) ,
4, 0.999864, 0, 0, 0.498522,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.452816,-99) ,
4, 0.999048, 0, 0, 0.497187,-99) );
// itree = 647
fBoostWeights.push_back(0.00989411);
fForest.push_back(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.530279,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.523946,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.501479,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.462984,-99) ,
9, 2.6773, 1, 0, 0.499985,-99) ,
8, 2.07299, 0, 0, 0.501168,-99) ,
0, 0.505709, 0, 0, 0.502324,-99) );
// itree = 648
fBoostWeights.push_back(0.0206718);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.511287,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.496837,-99) ,
4, 0.999995, 0, 0, 0.503853,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.505318,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.446948,-99) ,
8, -2.76517, 1, 0, 0.481772,-99) ,
4, 0.999887, 0, 0, 0.501977,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.519454,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.433677,-99) ,
8, -3.17646, 1, 0, 0.477511,-99) ,
4, 0.999524, 0, 0, 0.500715,-99) );
// itree = 649
fBoostWeights.push_back(0.0144512);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.50419,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.493733,-99) ,
3, 4.75378, 1, 0, 0.502202,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.456057,-99) ,
7, 2.1428, 1, 0, 0.500537,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.453045,-99) ,
9, 4.33774, 1, 0, 0.499121,-99) );
// itree = 650
fBoostWeights.push_back(0.0227343);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.525799,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.510067,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.462816,-99) ,
8, 0.588892, 0, 0, 0.500143,-99) ,
9, 2.10528, 1, 0, 0.507197,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.500839,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.492611,-99) ,
8, -3.44227, 1, 0, 0.495168,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.512587,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.479216,-99) ,
2, -0.0721639, 1, 0, 0.485677,-99) ,
0, 0.499995, 1, 0, 0.492067,-99) ,
8, -0.388594, 0, 0, 0.494672,-99) );
// itree = 651
fBoostWeights.push_back(0.0162107);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.509214,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.499033,-99) ,
8, -1.69236, 0, 0, 0.502279,-99) ,
NN(
0,
0,
-1, 0.504439, 1, -1, 0.484418,-99) ,
0, 0.502852, 1, 0, 0.500014,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.511496,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.479637,-99) ,
7, 0.420594, 0, 0, 0.490529,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.453093,-99) ,
9, 1.28166, 1, 0, 0.482815,-99) ,
2, -0.0716018, 0, 0, 0.497208,-99) );
// itree = 652
fBoostWeights.push_back(0.0107624);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 9.09102, 0, 1, 0.503954,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.477223,-99) ,
4, 0.999773, 0, 0, 0.503012,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.480387,-99) ,
4, 0.999524, 0, 0, 0.501861,-99) );
// itree = 653
fBoostWeights.push_back(0.0177412);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.706812, 1, 1, 0.522469,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.521382,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.497726,-99) ,
8, -4.79423, 1, 0, 0.498967,-99) ,
8, -1.49762, 0, 0, 0.500715,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.515419,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.482778,-99) ,
3, 2.33553, 1, 0, 0.500857,-99) ,
NN(
0,
0,
-1, 0.5019, 0, -1, 0.473625,-99) ,
8, 0.311628, 0, 0, 0.486818,-99) ,
9, 1.02914, 1, 0, 0.497259,-99) );
// itree = 654
fBoostWeights.push_back(0.0108871);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 8.78248, 0, 1, 0.502735,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.502873,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.458708,-99) ,
0, 0.499043, 0, 0, 0.477447,-99) ,
4, 0.999864, 0, 0, 0.500486,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.470711,-99) ,
4, 0.999048, 0, 0, 0.499602,-99) );
// itree = 655
fBoostWeights.push_back(0.0141798);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.500949, 0, 1, 0.51444,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.508957,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.497912,-99) ,
7, -0.469252, 1, 0, 0.500304,-99) ,
2, 0.0727818, 0, 0, 0.502435,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.512604,-99) ,
NN(
0,
0,
-1, -1.6937, 0, -1, 0.467442,-99) ,
9, -2.14082, 1, 0, 0.487288,-99) ,
7, -1.28555, 0, 0, 0.500905,-99) );
// itree = 656
fBoostWeights.push_back(0.0190739);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.558784,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.499944,-99) ,
8, -3.93558, 1, 0, 0.502884,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.503326,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.422118,-99) ,
7, -0.778746, 1, 0, 0.485422,-99) ,
9, -1.69694, 0, 0, 0.500412,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.554398,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.450584,-99) ,
7, 0.431076, 1, 0, 0.49389,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.461958,-99) ,
6, -951.286, 1, 0, 0.480666,-99) ,
9, 2.40213, 1, 0, 0.498381,-99) );
// itree = 657
fBoostWeights.push_back(0.0350476);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.999524, 1, 1, 0.520955,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.367473,-99) ,
6, -1.85715, 0, 0, 0.51007,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.556771,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.49965,-99) ,
8, 1.5538, 0, 0, 0.503271,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.458797,-99) ,
7, 1.8572, 1, 0, 0.500404,-99) ,
6, -951.286, 0, 0, 0.505202,-99) );
// itree = 658
fBoostWeights.push_back(0.0288494);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.541155,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.511673,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.483208,-99) ,
8, -1.09118, 1, 0, 0.504422,-99) ,
8, 1.69818, 0, 0, 0.506624,-99) ,
NN(
NN(
0,
0,
-1, 0.999524, 1, 1, 0.504896,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.366341,-99) ,
6, -1.85713, 0, 0, 0.494921,-99) ,
6, -951.286, 1, 0, 0.500865,-99) );
// itree = 659
fBoostWeights.push_back(0.0210185);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -0.168774, 0, 1, 0.51498,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.463788,-99) ,
2, -0.0710971, 0, 0, 0.506624,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.530198,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.493998,-99) ,
0, 0.490474, 1, 0, 0.495543,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.472189,-99) ,
4, 0.999524, 0, 0, 0.494283,-99) ,
7, -0.714176, 1, 0, 0.497104,-99) );
// itree = 660
fBoostWeights.push_back(0.0258487);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.509516,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.48133,-99) ,
7, -0.714121, 0, 0, 0.505735,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.504943,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.440741,-99) ,
7, -0.659625, 1, 0, 0.489028,-99) ,
9, -1.50903, 0, 0, 0.502639,-99) ,
NN(
0,
0,
-1, 2.29595, 0, -1, 0.482021,-99) ,
9, 2.0312, 1, 0, 0.499953,-99) );
// itree = 661
fBoostWeights.push_back(0.0152614);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.506612,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.49583,-99) ,
6, -951.286, 1, 0, 0.501263,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.455308,-99) ,
7, -1.571, 0, 0, 0.499668,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.478428,-99) ,
9, -2.21706, 0, 0, 0.498426,-99) );
// itree = 662
fBoostWeights.push_back(0.0163845);
fForest.push_back(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.539011,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.50841,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.495016,-99) ,
2, 0.0303285, 0, 0, 0.498571,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.470812,-99) ,
2, -0.214495, 0, 0, 0.497439,-99) ,
7, 2.14284, 0, 0, 0.499182,-99) );
// itree = 663
fBoostWeights.push_back(0.0122066);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.528494,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.502847,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.460991,-99) ,
7, -1.77533, 0, 0, 0.501673,-99) ,
7, 2.14288, 0, 0, 0.502826,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.457327,-99) ,
9, -2.56061, 0, 0, 0.501398,-99) );
// itree = 664
fBoostWeights.push_back(0.0120003);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.514002,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.49801,-99) ,
2, -0.0511432, 1, 0, 0.500774,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.47213,-99) ,
2, -0.214304, 0, 0, 0.499618,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.468484,-99) ,
9, -2.47158, 0, 0, 0.498473,-99) );
// itree = 665
fBoostWeights.push_back(0.0183888);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.50709,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.484886,-99) ,
4, 0.999909, 0, 0, 0.504679,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.502397,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.445267,-99) ,
7, -0.326026, 1, 0, 0.492964,-99) ,
9, -1.25366, 0, 0, 0.502195,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.471726,-99) ,
4, 0.999048, 0, 0, 0.501297,-99) );
// itree = 666
fBoostWeights.push_back(0.0237698);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.550152,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.504183,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.48198,-99) ,
9, 2.82566, 1, 0, 0.502019,-99) ,
7, -1.57141, 1, 0, 0.503643,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.532678,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.476935,-99) ,
8, -3.82865, 0, 0, 0.490797,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.433689,-99) ,
7, -0.381092, 1, 0, 0.481609,-99) ,
9, -1.34315, 0, 0, 0.499371,-99) );
// itree = 667
fBoostWeights.push_back(0.020012);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.0134221, 1, 1, 0.550798,-99) ,
NN(
0,
0,
-1, 2.1429, 1, -1, 0.496238,-99) ,
5, 0.0101876, 0, 0, 0.500632,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.397403,-99) ,
5, 0.0237713, 1, 0, 0.497966,-99) );
// itree = 668
fBoostWeights.push_back(0.0146342);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.50375,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.481357,-99) ,
7, -1.04067, 0, 0, 0.50134,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.477844,-99) ,
9, -2.26819, 0, 0, 0.500059,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.465507,-99) ,
7, 2.14288, 1, 0, 0.498776,-99) );
// itree = 669
fBoostWeights.push_back(0.0140495);
fForest.push_back(
NN(
NN(
0,
0,
-1, -951.286, 1, 1, 0.515336,-99) ,
NN(
0,
0,
-1, -0.0714836, 0, -1, 0.493588,-99) ,
0, 0.491424, 1, 0, 0.495081,-99) );
// itree = 670
fBoostWeights.push_back(0.0152897);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.35726, 0, 1, 0.516239,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.508828,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.494259,-99) ,
8, 0.718706, 0, 0, 0.495655,-99) ,
0, 0.504757, 0, 0, 0.496973,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.469974,-99) ,
2, -0.214346, 0, 0, 0.495869,-99) );
// itree = 671
fBoostWeights.push_back(0.00820497);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.524832,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.501844,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.483442,-99) ,
9, -2.32196, 0, 0, 0.500941,-99) ,
0, 0.489519, 1, 0, 0.501578,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.47127,-99) ,
7, 2.14284, 1, 0, 0.50046,-99) );
// itree = 672
fBoostWeights.push_back(0.014815);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.535766,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.52421,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.49734,-99) ,
8, -4.45471, 1, 0, 0.499069,-99) ,
4, 0.999524, 1, 0, 0.500923,-99) ,
NN(
0,
0,
-1, -0.142755, 0, -1, 0.475663,-99) ,
0, 0.492376, 0, 0, 0.498547,-99) );
// itree = 673
fBoostWeights.push_back(0.025879);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -0.252858, 1, 1, 0.511251,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.506761,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.460859,-99) ,
7, 0.00708858, 1, 0, 0.496957,-99) ,
8, -3.21528, 0, 0, 0.50513,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.505542,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.480594,-99) ,
9, 1.77733, 1, 0, 0.499092,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.432764,-99) ,
9, -0.304971, 0, 0, 0.492989,-99) ,
7, 0.714273, 1, 0, 0.501532,-99) );
// itree = 674
fBoostWeights.push_back(0.0116486);
fForest.push_back(
NN(
NN(
0,
0,
-1, 2.29255, 1, 1, 0.523233,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.51768,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.498814,-99) ,
8, -0.468929, 0, 0, 0.50127,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.470587,-99) ,
9, 3.47774, 1, 0, 0.499836,-99) ,
7, 1.85718, 0, 0, 0.50143,-99) );
// itree = 675
fBoostWeights.push_back(0.0226611);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.513874,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.487392,-99) ,
9, -1.39778, 0, 0, 0.508221,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.502024,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.480735,-99) ,
8, -2.67878, 0, 0, 0.496883,-99) ,
7, 0.428663, 1, 0, 0.503487,-99) ,
NN(
0,
0,
-1, -2.58658, 0, -1, 0.476746,-99) ,
9, -2.13337, 0, 0, 0.501763,-99) );
// itree = 676
fBoostWeights.push_back(0.0190572);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.538652,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.49878,-99) ,
8, -2.22273, 0, 0, 0.50299,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.50031,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.474902,-99) ,
8, -0.596714, 0, 0, 0.487611,-99) ,
9, 0.31815, 1, 0, 0.497262,-99) ,
NN(
0,
0,
-1, 0.074439, 1, -1, 0.480293,-99) ,
0, 0.493329, 0, 0, 0.495018,-99) );
// itree = 677
fBoostWeights.push_back(0.0103346);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.54163,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.498121,-99) ,
3, 9.08969, 0, 0, 0.499543,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.460363,-99) ,
4, 0.999048, 0, 0, 0.498469,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.468519,-99) ,
0, 0.505709, 1, 0, 0.497383,-99) );
// itree = 678
fBoostWeights.push_back(0.0322555);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.547485,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.510201,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.419483,-99) ,
7, 0.760582, 1, 0, 0.502988,-99) ,
8, -2.55938, 0, 0, 0.507891,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.509444,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.490162,-99) ,
7, 1.00003, 0, 0, 0.498873,-99) ,
NN(
0,
0,
-1, 0.49809, 1, -1, 0.482505,-99) ,
9, 1.52546, 1, 0, 0.492705,-99) ,
9, -0.092933, 1, 0, 0.500693,-99) );
// itree = 679
fBoostWeights.push_back(0.0208853);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.394345, 0, 1, 0.544218,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.503818,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.480144,-99) ,
9, 0.128176, 1, 0, 0.500819,-99) ,
8, -1.76007, 0, 0, 0.504179,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.512982,-99) ,
NN(
0,
0,
-1, -0.714088, 0, -1, 0.485476,-99) ,
8, 2.25815, 0, 0, 0.489669,-99) ,
9, 0.71673, 1, 0, 0.499877,-99) );
// itree = 680
fBoostWeights.push_back(0.013255);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.509321,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.497503,-99) ,
9, -0.731104, 1, 0, 0.501294,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.470893,-99) ,
7, -1.57141, 0, 0, 0.500119,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.469434,-99) ,
9, -2.39957, 0, 0, 0.498891,-99) );
// itree = 681
fBoostWeights.push_back(0.0111949);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.509692,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.498472,-99) ,
2, 0.0232979, 0, 0, 0.501936,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.484365,-99) ,
2, -0.132072, 0, 0, 0.501084,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.471511,-99) ,
2, -0.213645, 0, 0, 0.499861,-99) );
// itree = 682
fBoostWeights.push_back(0.0335974);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.998958, 0, 1, 0.507898,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.510602,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.363245,-99) ,
6, -1.85725, 0, 0, 0.499222,-99) ,
6, -951.286, 1, 0, 0.503789,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.51583,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.456843,-99) ,
9, -2.57426, 0, 0, 0.503555,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.410737,-99) ,
7, -0.472009, 1, 0, 0.489435,-99) ,
9, -1.48154, 0, 0, 0.5014,-99) );
// itree = 683
fBoostWeights.push_back(0.0137626);
fForest.push_back(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.520966,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.54158,-99) ,
NN(
0,
0,
-1, 0.999683, 0, -1, 0.494891,-99) ,
4, 0.999048, 1, 0, 0.496401,-99) ,
7, 2.14288, 0, 0, 0.497391,-99) );
// itree = 684
fBoostWeights.push_back(0.0156912);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.522136,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.491009,-99) ,
9, 4.09715, 1, 0, 0.513389,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.520192,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.49538,-99) ,
7, -1.85713, 1, 0, 0.496305,-99) ,
8, 0.178684, 0, 0, 0.498607,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.463574,-99) ,
4, 0.999048, 0, 0, 0.497584,-99) );
// itree = 685
fBoostWeights.push_back(0.0169171);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -0.0189509, 1, 1, 0.509643,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.517466,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.49426,-99) ,
0, 0.492377, 1, 0, 0.496605,-99) ,
3, 1.41178, 1, 0, 0.501036,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.472065,-99) ,
3, 9.25993, 1, 0, 0.500158,-99) );
// itree = 686
fBoostWeights.push_back(0.0151058);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -1.97941, 0, 1, 0.523435,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.504244,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.458546,-99) ,
9, -2.10989, 0, 0, 0.502377,-99) ,
7, -1.57125, 1, 0, 0.50369,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.473397,-99) ,
2, 0.21442, 1, 0, 0.502637,-99) );
// itree = 687
fBoostWeights.push_back(0.0179257);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 1.06874, 1, 1, 0.528583,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.505432,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.47243,-99) ,
8, -0.226526, 0, 0, 0.498157,-99) ,
9, 1.41986, 1, 0, 0.50705,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.501519,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.481449,-99) ,
9, -1.75264, 0, 0, 0.498202,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.438363,-99) ,
7, 1.85609, 1, 0, 0.496024,-99) ,
8, -1.33695, 0, 0, 0.499059,-99) );
// itree = 688
fBoostWeights.push_back(0.0175291);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.526481,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.5075,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.493243,-99) ,
3, 4.62455, 0, 0, 0.496114,-99) ,
7, 2.14288, 0, 0, 0.497301,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.470659,-99) ,
4, 0.999524, 0, 0, 0.495959,-99) );
// itree = 689
fBoostWeights.push_back(0.019121);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.577067, 1, 1, 0.507944,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.513534,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.492732,-99) ,
2, 0.0721267, 0, 0, 0.49583,-99) ,
8, -1.84054, 0, 0, 0.500113,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.456708,-99) ,
0, 0.490472, 0, 0, 0.498325,-99) );
// itree = 690
fBoostWeights.push_back(0.0130467);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.51408,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.496196,-99) ,
0, 0.491696, 1, 0, 0.497646,-99) ,
NN(
0,
0,
-1, 2.75778, 1, -1, 0.479754,-99) ,
0, 0.504757, 1, 0, 0.496531,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.462826,-99) ,
3, 9.37272, 1, 0, 0.495555,-99) );
// itree = 691
fBoostWeights.push_back(0.0169247);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -0.576994, 0, 1, 0.506676,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.482798,-99) ,
9, 3.05633, 1, 0, 0.505076,-99) ,
NN(
NN(
0,
0,
-1, 2.68937, 1, -1, 0.495689,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.517396,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.462033,-99) ,
7, -1.47606, 1, 0, 0.480611,-99) ,
7, -0.714154, 0, 0, 0.492424,-99) ,
0, 0.497138, 0, 0, 0.500057,-99) );
// itree = 692
fBoostWeights.push_back(0.00827332);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.544589,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.500529,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.478842,-99) ,
4, 0.999683, 0, 0, 0.499704,-99) ,
4, 0.999048, 1, 0, 0.501035,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.444635,-99) ,
3, 9.25993, 1, 0, 0.499389,-99) );
// itree = 693
fBoostWeights.push_back(0.0145877);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.999524, 1, 1, 0.505882,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.501753,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.489783,-99) ,
0, 0.496187, 1, 0, 0.49354,-99) ,
3, 2.30369, 1, 0, 0.50025,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.471051,-99) ,
3, 9.37272, 1, 0, 0.499405,-99) );
// itree = 694
fBoostWeights.push_back(0.0119323);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.535628,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.514564,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.497555,-99) ,
8, -4.03342, 1, 0, 0.499592,-99) ,
3, 9.12912, 0, 0, 0.500725,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.473465,-99) ,
4, 0.999524, 0, 0, 0.499374,-99) );
// itree = 695
fBoostWeights.push_back(0.0246057);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.523429,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.500518,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.427362,-99) ,
7, 0.525236, 1, 0, 0.494085,-99) ,
9, -0.405698, 0, 0, 0.497174,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.508507,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.483088,-99) ,
7, 1.28572, 1, 0, 0.496472,-99) ,
NN(
0,
0,
-1, -1.72849, 0, -1, 0.480998,-99) ,
7, 0.428619, 0, 0, 0.489595,-99) ,
8, -2.70844, 1, 0, 0.493041,-99) );
// itree = 696
fBoostWeights.push_back(0.0120976);
fForest.push_back(
NN(
NN(
0,
0,
-1, -951.286, 0, 1, 0.518971,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.535789,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.498821,-99) ,
4, 0.999524, 1, 0, 0.50027,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.509698,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.477027,-99) ,
0, 0.5019, 0, 0, 0.48513,-99) ,
2, 0.0715542, 1, 0, 0.497993,-99) ,
7, 1.85714, 0, 0, 0.499407,-99) );
// itree = 697
fBoostWeights.push_back(0.0118245);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.50325,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.470124,-99) ,
2, -0.205632, 0, 0, 0.50224,-99) ,
NN(
0,
0,
-1, -3.01566, 0, -1, 0.490468,-99) ,
0, 0.493329, 0, 0, 0.500721,-99) ,
NN(
0,
0,
-1, -3.15182, 1, -1, 0.472804,-99) ,
4, 0.999524, 0, 0, 0.499298,-99) );
// itree = 698
fBoostWeights.push_back(0.0224316);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.538151,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.531005,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.498373,-99) ,
7, -1.28548, 1, 0, 0.50022,-99) ,
9, -0.597789, 1, 0, 0.503134,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.502909,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.458891,-99) ,
9, -1.01353, 1, 0, 0.496724,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.538116,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.417887,-99) ,
9, -0.617599, 0, 0, 0.469195,-99) ,
7, 0.220741, 1, 0, 0.490908,-99) ,
8, -2.98998, 0, 0, 0.498533,-99) );
// itree = 699
fBoostWeights.push_back(0.0191615);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.509027,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.464542,-99) ,
9, -0.738458, 0, 0, 0.504597,-99) ,
NN(
0,
0,
-1, -0.0714192, 0, -1, 0.493932,-99) ,
7, 0.183609, 0, 0, 0.498825,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.465393,-99) ,
7, 2.14281, 1, 0, 0.497606,-99) );
// itree = 700
fBoostWeights.push_back(0.0208729);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.199863, 0, 1, 0.521968,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.488147,-99) ,
9, 3.30521, 1, 0, 0.514892,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.540348,-99) ,
NN(
0,
0,
-1, -1.59261, 0, -1, 0.494464,-99) ,
7, -1.85693, 1, 0, 0.496209,-99) ,
8, -1.31231, 0, 0, 0.501349,-99) );
// itree = 701
fBoostWeights.push_back(0.0107463);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.535214,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.514998,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.49839,-99) ,
7, 1.2858, 0, 0, 0.500905,-99) ,
3, 9.08466, 0, 0, 0.502033,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.471655,-99) ,
4, 0.999048, 0, 0, 0.501137,-99) );
// itree = 702
fBoostWeights.push_back(0.0161816);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 2.14285, 0, 1, 0.506129,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.484242,-99) ,
2, 0.214323, 1, 0, 0.505421,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.52763,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.492062,-99) ,
9, 1.59076, 1, 0, 0.511071,-99) ,
NN(
0,
0,
-1, 0.210013, 0, -1, 0.482124,-99) ,
8, -1.96538, 0, 0, 0.494457,-99) ,
0, 0.502852, 1, 0, 0.503873,-99) );
// itree = 703
fBoostWeights.push_back(0.0229879);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.509188,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.440411,-99) ,
9, -1.62099, 0, 0, 0.505972,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.500941,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.468665,-99) ,
3, 4.10501, 1, 0, 0.493726,-99) ,
9, 1.94077, 1, 0, 0.503976,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.516,-99) ,
NN(
0,
0,
-1, -1.80251, 0, -1, 0.487002,-99) ,
8, -4.78844, 1, 0, 0.491573,-99) ,
7, -0.714127, 0, 0, 0.501207,-99) );
// itree = 704
fBoostWeights.push_back(0.0148317);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.545994,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.494998,-99) ,
7, 0.143745, 0, 0, 0.520175,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.509711,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.496846,-99) ,
7, -0.428421, 1, 0, 0.500839,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.471033,-99) ,
2, -0.21455, 0, 0, 0.499751,-99) ,
0, 0.491424, 1, 0, 0.501197,-99) );
// itree = 705
fBoostWeights.push_back(0.0181233);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 8.78535, 0, 1, 0.505871,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.512433,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.443251,-99) ,
9, -0.315834, 1, 0, 0.486272,-99) ,
4, 0.999887, 0, 0, 0.504223,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.467121,-99) ,
4, 0.999524, 0, 0, 0.502403,-99) );
// itree = 706
fBoostWeights.push_back(0.0242201);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 2.43777, 1, 1, 0.533763,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.507094,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.490546,-99) ,
0, 0.499995, 1, 0, 0.501605,-99) ,
7, -0.999752, 1, 0, 0.504318,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.522719,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.494467,-99) ,
8, -3.71655, 0, 0, 0.501578,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.439762,-99) ,
7, -0.281088, 1, 0, 0.490623,-99) ,
9, -1.17123, 0, 0, 0.501106,-99) );
// itree = 707
fBoostWeights.push_back(0.0235104);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.541592,-99) ,
NN(
0,
0,
-1, 0.49809, 0, -1, 0.49322,-99) ,
6, -951.286, 1, 0, 0.512347,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.512663,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.491394,-99) ,
7, -0.673231, 1, 0, 0.493913,-99) ,
NN(
0,
0,
-1, -1.69378, 0, -1, 0.467896,-99) ,
7, -1.28555, 0, 0, 0.492263,-99) ,
8, -4.06022, 1, 0, 0.494688,-99) );
// itree = 708
fBoostWeights.push_back(0.00923707);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.526983,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.499715,-99) ,
8, -4.13857, 1, 0, 0.501827,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.468758,-99) ,
7, -1.57141, 0, 0, 0.500459,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.459913,-99) ,
9, -2.57238, 0, 0, 0.49927,-99) );
// itree = 709
fBoostWeights.push_back(0.0121317);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.538044,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.517161,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.498562,-99) ,
7, 1.136, 0, 0, 0.50028,-99) ,
4, 0.999048, 1, 0, 0.501429,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.518803,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.4845,-99) ,
9, 1.38621, 0, 0, 0.496584,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.450446,-99) ,
7, 2.31975, 1, 0, 0.484936,-99) ,
7, 1.57147, 1, 0, 0.499776,-99) );
// itree = 710
fBoostWeights.push_back(0.0191161);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.54878,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.499867,-99) ,
9, -0.905101, 0, 0, 0.518054,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.504322,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.48013,-99) ,
9, -1.67001, 0, 0, 0.502241,-99) ,
7, -1.28555, 1, 0, 0.503853,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.51521,-99) ,
NN(
0,
0,
-1, 0.495777, 1, -1, 0.472132,-99) ,
0, 0.5019, 0, 0, 0.482792,-99) ,
2, 0.0713089, 1, 0, 0.500757,-99) );
// itree = 711
fBoostWeights.push_back(0.0125406);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.513871,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.499351,-99) ,
8, -4.0063, 1, 0, 0.501517,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.460541,-99) ,
7, 2.1428, 1, 0, 0.500211,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.512212,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.475368,-99) ,
9, 4.23026, 1, 0, 0.494837,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.450429,-99) ,
8, 1.27759, 0, 0, 0.480752,-99) ,
9, 2.41454, 1, 0, 0.498227,-99) );
// itree = 712
fBoostWeights.push_back(0.03425);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -0.0612431, 0, 1, 0.515513,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.50756,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.460225,-99) ,
7, -0.0610105, 1, 0, 0.498389,-99) ,
8, -3.21528, 0, 0, 0.507567,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.515371,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.488707,-99) ,
9, 0.505464, 1, 0, 0.498838,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.528132,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.41866,-99) ,
9, -0.454627, 0, 0, 0.46387,-99) ,
8, -2.84754, 0, 0, 0.492777,-99) ,
7, 0.428574, 1, 0, 0.501832,-99) );
// itree = 713
fBoostWeights.push_back(0.0203471);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.5162,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.497309,-99) ,
7, 0.238144, 0, 0, 0.503272,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.502138,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.474138,-99) ,
7, 1.38099, 0, 0, 0.49165,-99) ,
7, 1.00003, 1, 0, 0.50078,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.511261,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.487674,-99) ,
0, 0.494262, 0, 0, 0.49229,-99) ,
NN(
0,
0,
-1, -0.142319, 0, -1, 0.476526,-99) ,
0, 0.494961, 1, 0, 0.487897,-99) ,
0, 0.496186, 0, 0, 0.496729,-99) );
// itree = 714
fBoostWeights.push_back(0.0182848);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -1.85885, 0, 1, 0.535943,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.49899,-99) ,
6, -951.286, 1, 0, 0.51835,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.524829,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.505524,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.491172,-99) ,
6, -951.286, 0, 0, 0.498367,-99) ,
8, 2.1619, 0, 0, 0.499612,-99) ,
0, 0.503804, 0, 0, 0.5015,-99) );
// itree = 715
fBoostWeights.push_back(0.023365);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.538913,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.514053,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.49338,-99) ,
4, 0.999977, 1, 0, 0.499307,-99) ,
4, 0.999524, 1, 0, 0.501289,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.510479,-99) ,
NN(
0,
0,
-1, 2.45503, 1, -1, 0.481711,-99) ,
7, 2.14289, 0, 0, 0.487038,-99) ,
7, 1.00008, 1, 0, 0.498216,-99) );
// itree = 716
fBoostWeights.push_back(0.0111645);
fForest.push_back(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.533378,-99) ,
NN(
NN(
0,
0,
-1, 0.146738, 0, 1, 0.502905,-99) ,
NN(
0,
0,
-1, 1.71655, 0, -1, 0.47749,-99) ,
9, 2.77661, 1, 0, 0.500993,-99) ,
7, 2.14288, 0, 0, 0.502335,-99) );
// itree = 717
fBoostWeights.push_back(0.0124462);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.999524, 1, 1, 0.503501,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.481564,-99) ,
0, 0.490472, 0, 0, 0.502663,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.521534,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.48788,-99) ,
7, 1.23162, 0, 0, 0.49521,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.46589,-99) ,
7, -0.713655, 0, 0, 0.488674,-99) ,
2, 0.0714181, 1, 0, 0.500594,-99) );
// itree = 718
fBoostWeights.push_back(0.0227922);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.513605,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.497772,-99) ,
6, -951.286, 1, 0, 0.505627,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.467552,-99) ,
7, 2.29254, 1, 0, 0.504265,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.53251,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.495947,-99) ,
8, -4.24749, 0, 0, 0.509166,-99) ,
NN(
0,
0,
-1, -0.512698, 0, -1, 0.473641,-99) ,
9, -1.63549, 1, 0, 0.490785,-99) ,
7, -0.714137, 0, 0, 0.501249,-99) );
// itree = 719
fBoostWeights.push_back(0.0135897);
fForest.push_back(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.529844,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.502528,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.471092,-99) ,
9, 2.71991, 1, 0, 0.501401,-99) ,
NN(
0,
0,
-1, -951.286, 0, -1, 0.480117,-99) ,
0, 0.493329, 0, 0, 0.498619,-99) ,
8, 2.09155, 0, 0, 0.500135,-99) );
// itree = 720
fBoostWeights.push_back(0.0115597);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.531528,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.484105,-99) ,
6, -951.286, 1, 0, 0.512815,-99) ,
NN(
0,
0,
-1, 0.816132, 1, -1, 0.49752,-99) ,
8, 0.491749, 0, 0, 0.499179,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.462488,-99) ,
0, 0.489519, 0, 0, 0.498255,-99) );
// itree = 721
fBoostWeights.push_back(0.0241719);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.52411,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.498668,-99) ,
7, 1.76191, 1, 0, 0.514059,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.4764,-99) ,
9, 0.0354839, 0, 0, 0.509218,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.562835,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.497829,-99) ,
8, -2.65632, 0, 0, 0.505091,-99) ,
NN(
0,
0,
-1, -0.0716793, 0, -1, 0.485929,-99) ,
9, -0.2213, 1, 0, 0.497805,-99) ,
7, 0.999999, 0, 0, 0.500359,-99) );
// itree = 722
fBoostWeights.push_back(0.0154451);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.53689,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.498826,-99) ,
9, -1.19462, 0, 0, 0.524302,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.509059,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.484801,-99) ,
0, 0.504666, 1, 0, 0.497208,-99) ,
9, 0.447015, 1, 0, 0.514278,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.505534,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.497203,-99) ,
0, 0.499258, 1, 0, 0.500937,-99) ,
NN(
0,
0,
-1, -2.06079, 1, -1, 0.49246,-99) ,
0, 0.497047, 0, 0, 0.497113,-99) ,
0, 0.502852, 0, 0, 0.499587,-99) );
// itree = 723
fBoostWeights.push_back(0.0152192);
fForest.push_back(
NN(
NN(
0,
0,
-1, -3.0926, 1, 1, 0.519599,-99) ,
NN(
NN(
0,
0,
-1, -3.59682, 1, 1, 0.50535,-99) ,
NN(
0,
0,
-1, 0.498106, 1, -1, 0.471895,-99) ,
9, -1.92942, 0, 0, 0.503224,-99) ,
7, -1.57122, 1, 0, 0.504265,-99) );
// itree = 724
fBoostWeights.push_back(0.0136673);
fForest.push_back(
NN(
NN(
0,
0,
-1, -0.838755, 0, 1, 0.528328,-99) ,
NN(
NN(
0,
0,
-1, 0.999524, 1, 1, 0.504312,-99) ,
NN(
0,
0,
-1, -2.03617, 0, -1, 0.487873,-99) ,
7, 1.16325, 1, 0, 0.502357,-99) ,
7, 1.85714, 0, 0, 0.504147,-99) );
// itree = 725
fBoostWeights.push_back(0.0135315);
fForest.push_back(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.518778,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.504691,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.487117,-99) ,
9, 3.45236, 1, 0, 0.503725,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.453999,-99) ,
9, -2.38109, 0, 0, 0.502309,-99) ,
7, -1.85692, 1, 0, 0.502916,-99) );
// itree = 726
fBoostWeights.push_back(0.0277386);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.588514,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.486576,-99) ,
7, 0.198392, 0, 0, 0.527406,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.523093,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.497877,-99) ,
7, -0.714154, 1, 0, 0.500984,-99) ,
9, -0.259951, 1, 0, 0.505039,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.536991,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.496966,-99) ,
8, -3.27589, 0, 0, 0.504001,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.524962,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.423921,-99) ,
9, -0.541872, 0, 0, 0.464318,-99) ,
7, 0.268534, 1, 0, 0.495703,-99) ,
8, -2.91496, 0, 0, 0.501342,-99) );
// itree = 727
fBoostWeights.push_back(0.0178098);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.533301,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.496163,-99) ,
7, -1.97958, 0, 0, 0.516711,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.505256,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.485562,-99) ,
7, -0.700638, 0, 0, 0.502668,-99) ,
NN(
0,
0,
-1, 0.498092, 1, -1, 0.466108,-99) ,
9, -1.92942, 0, 0, 0.500414,-99) ,
7, -1.57141, 1, 0, 0.501434,-99) );
// itree = 728
fBoostWeights.push_back(0.0245103);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.547177,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.536648,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.465316,-99) ,
9, -1.93444, 0, 0, 0.502266,-99) ,
7, -1.39525, 1, 0, 0.516531,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.523929,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.493935,-99) ,
3, 1.58642, 0, 0, 0.511952,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.504671,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.489497,-99) ,
6, -951.286, 0, 0, 0.496888,-99) ,
8, 1.19412, 0, 0, 0.498166,-99) ,
8, -4.03342, 1, 0, 0.500433,-99) );
// itree = 729
fBoostWeights.push_back(0.0115061);
fForest.push_back(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.522286,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.502643,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.456511,-99) ,
7, -1.57125, 0, 0, 0.500859,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.473738,-99) ,
9, -2.50949, 0, 0, 0.499955,-99) ,
0, 0.490472, 1, 0, 0.500981,-99) );
// itree = 730
fBoostWeights.push_back(0.0179608);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.492331, 0, 1, 0.513691,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.51481,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.484782,-99) ,
7, 1.47635, 0, 0, 0.49671,-99) ,
7, 0.714502, 1, 0, 0.508696,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.503111,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.462473,-99) ,
7, -1.57122, 0, 0, 0.500187,-99) ,
NN(
0,
0,
-1, -1.85701, 0, -1, 0.490957,-99) ,
6, -951.286, 1, 0, 0.49563,-99) ,
0, 0.495233, 1, 0, 0.498871,-99) );
// itree = 731
fBoostWeights.push_back(0.0137824);
fForest.push_back(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.529905,-99) ,
NN(
NN(
0,
0,
-1, 0.499044, 0, 1, 0.517942,-99) ,
NN(
0,
0,
-1, 1.49114, 1, -1, 0.494922,-99) ,
7, 1.84358, 0, 0, 0.496574,-99) ,
7, -1.85696, 1, 0, 0.497814,-99) );
// itree = 732
fBoostWeights.push_back(0.0155937);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.519733,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.499234,-99) ,
2, -0.038236, 1, 0, 0.50337,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.469195,-99) ,
3, 4.27825, 1, 0, 0.50195,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.508556,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.482929,-99) ,
9, -0.72869, 1, 0, 0.494293,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.463952,-99) ,
9, 1.56127, 1, 0, 0.4895,-99) ,
3, 4.71771, 1, 0, 0.499601,-99) );
// itree = 733
fBoostWeights.push_back(0.0112742);
fForest.push_back(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.530485,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.522083,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.50238,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.47782,-99) ,
9, 2.25277, 1, 0, 0.500709,-99) ,
8, 2.07875, 0, 0, 0.501741,-99) ,
0, 0.505709, 0, 0, 0.502879,-99) );
// itree = 734
fBoostWeights.push_back(0.0180893);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.537556,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.499534,-99) ,
6, -951.286, 1, 0, 0.514651,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.518758,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.462159,-99) ,
7, -1.76168, 0, 0, 0.504808,-99) ,
NN(
0,
0,
-1, -1.1658, 0, -1, 0.493496,-99) ,
7, -0.999808, 1, 0, 0.494781,-99) ,
8, -4.25254, 1, 0, 0.496582,-99) );
// itree = 735
fBoostWeights.push_back(0.0142813);
fForest.push_back(
NN(
NN(
0,
0,
-1, 0.497138, 1, 1, 0.525031,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.502397,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.463311,-99) ,
9, -2.24322, 0, 0, 0.500862,-99) ,
NN(
0,
0,
-1, -0.127613, 0, -1, 0.488399,-99) ,
7, 0.823223, 1, 0, 0.497403,-99) ,
7, -1.57122, 1, 0, 0.49916,-99) );
// itree = 736
fBoostWeights.push_back(0.0146659);
fForest.push_back(
NN(
NN(
0,
0,
-1, -2.35689, 0, 1, 0.523647,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.525763,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.509919,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.495681,-99) ,
8, -3.67966, 1, 0, 0.4976,-99) ,
8, 2.6478, 0, 0, 0.498793,-99) ,
8, -4.34575, 1, 0, 0.500733,-99) );
// itree = 737
fBoostWeights.push_back(0.0215273);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.556229,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.494066,-99) ,
9, -1.00135, 0, 0, 0.518,-99) ,
NN(
NN(
0,
0,
-1, 1.1634, 0, 1, 0.504994,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.50317,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.36333,-99) ,
6, -1.85732, 0, 0, 0.492727,-99) ,
6, -951.286, 1, 0, 0.498872,-99) ,
7, -1.28552, 1, 0, 0.500878,-99) );
// itree = 738
fBoostWeights.push_back(0.0301759);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.515164,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.490426,-99) ,
7, 1.77556, 1, 0, 0.509604,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.554555,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.431236,-99) ,
9, -0.433726, 0, 0, 0.482541,-99) ,
8, -2.8303, 0, 0, 0.5047,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.507099,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.491347,-99) ,
8, -3.28343, 0, 0, 0.500081,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.514172,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.476044,-99) ,
7, -0.0611565, 0, 0, 0.487305,-99) ,
2, -0.0710971, 0, 0, 0.497902,-99) ,
7, 0.428663, 0, 0, 0.500588,-99) );
// itree = 739
fBoostWeights.push_back(0.0131042);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -1.24808, 1, 1, 0.51788,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.500638,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.440268,-99) ,
7, -1.69389, 0, 0, 0.498616,-99) ,
8, -4.28293, 1, 0, 0.500433,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.516649,-99) ,
NN(
0,
0,
-1, -951.286, 1, -1, 0.463829,-99) ,
8, -0.748601, 0, 0, 0.481252,-99) ,
7, 1.57138, 1, 0, 0.498569,-99) );
// itree = 740
fBoostWeights.push_back(0.0135042);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.531031,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.497018,-99) ,
7, 2.14289, 0, 0, 0.498352,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.462636,-99) ,
4, 0.999751, 0, 0, 0.497284,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.460862,-99) ,
4, 0.999524, 0, 0, 0.495492,-99) );
// itree = 741
fBoostWeights.push_back(0.0240158);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.530804,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.540433,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.457074,-99) ,
9, -1.76916, 0, 0, 0.498562,-99) ,
7, -1.18801, 1, 0, 0.51113,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.503395,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.491977,-99) ,
0, 0.497138, 1, 0, 0.496535,-99) ,
NN(
0,
0,
-1, -0.142809, 0, -1, 0.483834,-99) ,
2, -0.0716846, 0, 0, 0.494454,-99) ,
8, -3.9435, 1, 0, 0.496814,-99) );
// itree = 742
fBoostWeights.push_back(0.0271082);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -951.286, 1, 1, 0.524452,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.549509,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.430045,-99) ,
9, -1.61354, 0, 0, 0.497506,-99) ,
7, -0.768071, 1, 0, 0.513067,-99) ,
NN(
NN(
0,
0,
-1, 1.85716, 0, 1, 0.504324,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.528162,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.490926,-99) ,
9, -1.39673, 1, 0, 0.493906,-99) ,
8, -1.2412, 0, 0, 0.497148,-99) ,
8, -3.83621, 1, 0, 0.499737,-99) );
// itree = 743
fBoostWeights.push_back(0.0117234);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -0.344616, 0, 1, 0.510415,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.501091,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.472369,-99) ,
4, 0.999524, 0, 0, 0.499637,-99) ,
0, 0.499995, 0, 0, 0.503223,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.476204,-99) ,
9, 3.84063, 1, 0, 0.502109,-99) );
// itree = 744
fBoostWeights.push_back(0.0199507);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.544329,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.532529,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.478432,-99) ,
9, -1.85546, 0, 0, 0.505349,-99) ,
7, -1.23754, 1, 0, 0.520656,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.528052,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.526996,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.496248,-99) ,
7, 1.85717, 0, 0, 0.498531,-99) ,
4, 0.999524, 1, 0, 0.499997,-99) ,
8, -4.03342, 1, 0, 0.502558,-99) );
// itree = 745
fBoostWeights.push_back(0.0220315);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 1.27973, 0, 1, 0.509604,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.513581,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.494432,-99) ,
8, -1.24031, 0, 0, 0.495818,-99) ,
0, 0.499043, 0, 0, 0.501658,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.528094,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.477504,-99) ,
0, 0.503169, 1, 0, 0.502961,-99) ,
NN(
0,
0,
-1, 0.143166, 0, -1, 0.476415,-99) ,
0, 0.500947, 0, 0, 0.483979,-99) ,
9, 1.30911, 1, 0, 0.498005,-99) );
// itree = 746
fBoostWeights.push_back(0.0142361);
fForest.push_back(
NN(
NN(
0,
0,
-1, 0.498089, 1, 1, 0.523866,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.549855,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.496984,-99) ,
3, 8.75399, 0, 0, 0.498976,-99) ,
NN(
0,
0,
-1, -0.469166, 1, -1, 0.479005,-99) ,
4, 0.999887, 0, 0, 0.497287,-99) ,
4, 0.999524, 1, 0, 0.498737,-99) );
// itree = 747
fBoostWeights.push_back(0.0190787);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.535697,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.508102,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.493568,-99) ,
7, -1.57121, 0, 0, 0.507212,-99) ,
0, 0.493102, 1, 0, 0.508108,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.517611,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.489735,-99) ,
7, 0.428569, 0, 0, 0.500793,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.478847,-99) ,
1, -0.00204691, 0, 0, 0.493578,-99) ,
0, 0.492376, 0, 0, 0.50671,-99) );
// itree = 748
fBoostWeights.push_back(0.00848122);
fForest.push_back(
NN(
NN(
0,
0,
-1, 8.85038, 0, 1, 0.503219,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.476633,-99) ,
4, 0.999524, 0, 0, 0.501872,-99) );
// itree = 749
fBoostWeights.push_back(0.0182549);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.528116,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.501201,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.47795,-99) ,
2, -0.213875, 0, 0, 0.500171,-99) ,
8, -1.53533, 0, 0, 0.50205,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.529359,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.475391,-99) ,
6, -951.286, 0, 0, 0.498076,-99) ,
NN(
0,
0,
-1, -951.286, 1, -1, 0.477567,-99) ,
7, 1.28577, 0, 0, 0.484182,-99) ,
9, 0.926524, 1, 0, 0.497334,-99) );
// itree = 750
fBoostWeights.push_back(0.0242561);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.554512,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.498038,-99) ,
8, -3.49937, 1, 0, 0.502886,-99) ,
NN(
0,
0,
-1, -0.319482, 1, -1, 0.486765,-99) ,
9, -1.25487, 0, 0, 0.498672,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.505827,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.53083,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.449639,-99) ,
8, 1.40311, 0, 0, 0.47535,-99) ,
6, -951.286, 0, 0, 0.48683,-99) ,
8, -0.541537, 1, 0, 0.496531,-99) );
// itree = 751
fBoostWeights.push_back(0.0214707);
fForest.push_back(
NN(
NN(
0,
0,
-1, 0.498091, 0, 1, 0.517188,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.557733,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.494723,-99) ,
9, -0.797652, 0, 0, 0.503022,-99) ,
NN(
0,
0,
-1, -0.169995, 0, -1, 0.491388,-99) ,
8, -3.13009, 1, 0, 0.495798,-99) ,
7, 1.57149, 0, 0, 0.498069,-99) );
// itree = 752
fBoostWeights.push_back(0.011153);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.528389, 1, 1, 0.502273,-99) ,
NN(
0,
0,
-1, -0.714166, 0, -1, 0.493067,-99) ,
3, 4.50116, 1, 0, 0.500335,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.518432,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.478632,-99) ,
7, 0.714669, 1, 0, 0.498515,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.46277,-99) ,
6, -951.286, 1, 0, 0.484026,-99) ,
9, 2.48002, 1, 0, 0.498735,-99) );
// itree = 753
fBoostWeights.push_back(0.0358654);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 1.57087, 0, 1, 0.516701,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.5215,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.35532,-99) ,
7, 0.715846, 1, 0, 0.456344,-99) ,
6, -1.00013, 0, 0, 0.503918,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.501931,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.453636,-99) ,
7, -1.61226, 0, 0, 0.498571,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.447785,-99) ,
7, 1.85714, 1, 0, 0.495401,-99) ,
6, -951.286, 0, 0, 0.499646,-99) );
// itree = 754
fBoostWeights.push_back(0.0161395);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.521682,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.489965,-99) ,
0, 0.499996, 1, 0, 0.511649,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.515781,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.494981,-99) ,
8, -4.49154, 1, 0, 0.496443,-99) ,
7, 1.40812, 0, 0, 0.497888,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.462027,-99) ,
7, 2.14288, 1, 0, 0.49658,-99) );
// itree = 755
fBoostWeights.push_back(0.00974033);
fForest.push_back(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.53003,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.511224,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.499592,-99) ,
7, 1.14971, 0, 0, 0.501907,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.459753,-99) ,
9, -2.29516, 0, 0, 0.500422,-99) ,
7, -1.85691, 1, 0, 0.501535,-99) );
// itree = 756
fBoostWeights.push_back(0.00837052);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 1.54316, 0, 1, 0.520399,-99) ,
NN(
0,
0,
-1, 1.72742, 1, -1, 0.498444,-99) ,
7, 1.85713, 0, 0, 0.499921,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.463471,-99) ,
2, -0.214166, 0, 0, 0.498449,-99) );
// itree = 757
fBoostWeights.push_back(0.00876422);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.533129,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.533225,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.498578,-99) ,
2, 0.207989, 0, 0, 0.499609,-99) ,
3, 8.71932, 0, 0, 0.500907,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.468036,-99) ,
4, 0.999048, 0, 0, 0.499956,-99) );
// itree = 758
fBoostWeights.push_back(0.0186743);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.545311,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.512883,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.491019,-99) ,
6, -951.286, 1, 0, 0.503802,-99) ,
9, 2.50594, 1, 0, 0.516767,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.506464,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.494759,-99) ,
9, 0.626134, 1, 0, 0.503954,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.461789,-99) ,
9, -2.60024, 0, 0, 0.502517,-99) ,
8, 0.0345393, 0, 0, 0.504511,-99) );
// itree = 759
fBoostWeights.push_back(0.0207486);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -0.574137, 0, 1, 0.510543,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.507764,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.486964,-99) ,
3, 2.92621, 1, 0, 0.500275,-99) ,
7, 0.714372, 0, 0, 0.505578,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.532902,-99) ,
NN(
0,
0,
-1, 0.760215, 1, -1, 0.491866,-99) ,
8, -2.51899, 0, 0, 0.495962,-99) ,
9, -0.092933, 0, 0, 0.500555,-99) );
// itree = 760
fBoostWeights.push_back(0.0199014);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.605642, 1, 1, 0.510558,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.515046,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.4939,-99) ,
0, 0.503805, 0, 0, 0.496425,-99) ,
3, 2.24029, 1, 0, 0.503982,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.461433,-99) ,
3, 9.10638, 1, 0, 0.502589,-99) );
// itree = 761
fBoostWeights.push_back(0.0175866);
fForest.push_back(
NN(
NN(
0,
0,
-1, 0.499995, 0, 1, 0.520632,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.504636,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.48085,-99) ,
9, -1.69531, 0, 0, 0.502683,-99) ,
NN(
0,
0,
-1, -1.92935, 1, -1, 0.482429,-99) ,
0, 0.502852, 1, 0, 0.499911,-99) ,
7, -1.28571, 1, 0, 0.502041,-99) );
// itree = 762
fBoostWeights.push_back(0.0176436);
fForest.push_back(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.521928,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.514422,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.494133,-99) ,
0, 0.493329, 1, 0, 0.496898,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.456511,-99) ,
4, 0.999048, 0, 0, 0.495816,-99) ,
9, -2.21706, 1, 0, 0.497337,-99) );
// itree = 763
fBoostWeights.push_back(0.00988059);
fForest.push_back(
NN(
NN(
0,
0,
-1, 9.13153, 0, 1, 0.503577,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.468812,-99) ,
4, 0.999524, 0, 0, 0.501861,-99) );
// itree = 764
fBoostWeights.push_back(0.0119536);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.525224,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.503074,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.471073,-99) ,
4, 0.999048, 0, 0, 0.50213,-99) ,
8, -4.58624, 1, 0, 0.503434,-99) ,
NN(
0,
0,
-1, 1.74855, 0, -1, 0.483193,-99) ,
9, 2.77661, 1, 0, 0.50183,-99) );
// itree = 765
fBoostWeights.push_back(0.0157999);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.523646,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.496691,-99) ,
8, -1.69679, 0, 0, 0.499438,-99) ,
NN(
0,
0,
-1, -0.0473203, 0, -1, 0.487672,-99) ,
9, 0.986613, 1, 0, 0.496745,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.464537,-99) ,
9, 4.2114, 1, 0, 0.495695,-99) );
// itree = 766
fBoostWeights.push_back(0.0232079);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.538192,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.530137,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.496269,-99) ,
8, -2.21478, 0, 0, 0.49975,-99) ,
7, -1.78339, 1, 0, 0.50183,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.517763,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.491736,-99) ,
6, -951.286, 0, 0, 0.503493,-99) ,
NN(
0,
0,
-1, -1.05425, 0, -1, 0.477488,-99) ,
7, 0.714391, 0, 0, 0.490841,-99) ,
9, 0.341677, 1, 0, 0.497739,-99) );
// itree = 767
fBoostWeights.push_back(0.0104555);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.999048, 1, 1, 0.503588,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.465646,-99) ,
3, 7.56538, 1, 0, 0.502304,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.475081,-99) ,
3, 9.32353, 1, 0, 0.501502,-99) );
// itree = 768
fBoostWeights.push_back(0.0137205);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.529058,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.495892,-99) ,
3, 1.81681, 0, 0, 0.515528,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.501283,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.484695,-99) ,
9, 1.43732, 1, 0, 0.498101,-99) ,
0, 0.493329, 1, 0, 0.500496,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.467872,-99) ,
3, 9.07131, 1, 0, 0.499447,-99) );
// itree = 769
fBoostWeights.push_back(0.0184855);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 2.92643, 1, 1, 0.530326,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.509339,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.484787,-99) ,
3, 1.20699, 0, 0, 0.501701,-99) ,
7, 0.714328, 0, 0, 0.512887,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.535616,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.497649,-99) ,
4, 0.999524, 1, 0, 0.50021,-99) ,
NN(
0,
0,
-1, -951.287, 1, -1, 0.470203,-99) ,
9, 0.921984, 1, 0, 0.497616,-99) ,
8, -0.758607, 0, 0, 0.500788,-99) );
// itree = 770
fBoostWeights.push_back(0.0184749);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.527543,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.496254,-99) ,
7, -0.142797, 0, 0, 0.516121,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.504226,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.487898,-99) ,
9, 0.188079, 1, 0, 0.499932,-99) ,
8, -0.650235, 0, 0, 0.50268,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.467842,-99) ,
9, 4.15532, 1, 0, 0.501495,-99) );
// itree = 771
fBoostWeights.push_back(0.0145171);
fForest.push_back(
NN(
NN(
0,
0,
-1, -951.286, 1, 1, 0.519952,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.52962,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.496267,-99) ,
0, 0.506163, 0, 0, 0.49736,-99) ,
NN(
0,
0,
-1, -0.142922, 0, -1, 0.480151,-99) ,
0, 0.492376, 0, 0, 0.495728,-99) ,
8, -4.28007, 1, 0, 0.497864,-99) );
// itree = 772
fBoostWeights.push_back(0.0132011);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.534684,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.513003,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.452495,-99) ,
7, -1.01289, 1, 0, 0.493941,-99) ,
9, -1.80343, 0, 0, 0.50808,-99) ,
NN(
0,
0,
-1, -1.57125, 0, -1, 0.496989,-99) ,
8, -3.92379, 1, 0, 0.498606,-99) );
// itree = 773
fBoostWeights.push_back(0.0109719);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -951.286, 1, 1, 0.52765,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.508518,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.491195,-99) ,
9, -1.08323, 0, 0, 0.500064,-99) ,
9, -0.114366, 0, 0, 0.51465,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.500944,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.451724,-99) ,
9, -2.30753, 0, 0, 0.499224,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.475474,-99) ,
7, -1.85713, 0, 0, 0.498416,-99) ,
0, 0.493329, 1, 0, 0.500679,-99) );
// itree = 774
fBoostWeights.push_back(0.0135855);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.512999,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.487891,-99) ,
7, -1.3807, 0, 0, 0.510748,-99) ,
NN(
0,
0,
-1, 0.999524, 1, 1, 0.501451,-99) ,
0, 0.499043, 0, 0, 0.505365,-99) ,
NN(
0,
0,
-1, -951.286, 0, -1, 0.485466,-99) ,
7, 1.85716, 1, 0, 0.504128,-99) );
// itree = 775
fBoostWeights.push_back(0.0204721);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.791616, 0, 1, 0.528517,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.507217,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.483567,-99) ,
6, -0.146596, 0, 0, 0.496323,-99) ,
6, -951.286, 1, 0, 0.513158,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.515493,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.484806,-99) ,
0, 0.502171, 1, 0, 0.508248,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.526589,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.494017,-99) ,
8, 2.09564, 0, 0, 0.495626,-99) ,
3, 4.71771, 0, 0, 0.498066,-99) ,
0, 0.493329, 1, 0, 0.500129,-99) );
// itree = 776
fBoostWeights.push_back(0.0187897);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.539865,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.536037,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.459504,-99) ,
9, -2.19335, 1, 0, 0.503056,-99) ,
9, -0.217995, 0, 0, 0.512753,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.531447,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.497893,-99) ,
8, -0.758344, 0, 0, 0.500964,-99) ,
NN(
0,
0,
-1, 0.683517, 0, -1, 0.485428,-99) ,
9, 2.14247, 1, 0, 0.498946,-99) ,
7, -1.28553, 1, 0, 0.500365,-99) );
// itree = 777
fBoostWeights.push_back(0.0133728);
fForest.push_back(
NN(
NN(
0,
0,
-1, -0.210606, 1, 1, 0.505468,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.469887,-99) ,
4, 0.999524, 0, 0, 0.50371,-99) );
// itree = 778
fBoostWeights.push_back(0.0243064);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.507308,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.479123,-99) ,
0, 0.492377, 0, 0, 0.504878,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.517215,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.477602,-99) ,
9, 0.128339, 1, 0, 0.493824,-99) ,
8, -2.45463, 1, 0, 0.502414,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.514702,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.508737,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.484214,-99) ,
9, 0.865715, 1, 0, 0.489738,-99) ,
8, 2.37486, 0, 0, 0.492938,-99) ,
8, -1.7302, 1, 0, 0.499281,-99) );
// itree = 779
fBoostWeights.push_back(0.0193726);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.75664, 1, 1, 0.540892,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.533409,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.497929,-99) ,
8, 1.51521, 0, 0, 0.499828,-99) ,
5, 0.0101531, 0, 0, 0.503054,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.373478,-99) ,
5, 0.0236981, 1, 0, 0.499791,-99) );
// itree = 780
fBoostWeights.push_back(0.0127423);
fForest.push_back(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.535103,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.503672,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.494408,-99) ,
7, -0.562706, 0, 0, 0.500961,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.478069,-99) ,
7, 1.65299, 1, 0, 0.499771,-99) ,
7, 2.14285, 0, 0, 0.501207,-99) );
// itree = 781
fBoostWeights.push_back(0.0104285);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.52481,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.501523,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.45752,-99) ,
9, 2.11737, 1, 0, 0.500199,-99) ,
8, 0.597329, 0, 0, 0.501468,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.471871,-99) ,
9, 3.38031, 1, 0, 0.499855,-99) );
// itree = 782
fBoostWeights.push_back(0.0131298);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.534008,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.498605,-99) ,
9, -2.26488, 0, 0, 0.515139,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.527129,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.499864,-99) ,
0, 0.499451, 1, 0, 0.5024,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.501636,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.486301,-99) ,
6, -951.286, 0, 0, 0.493836,-99) ,
0, 0.499043, 0, 0, 0.497468,-99) ,
8, -4.28293, 1, 0, 0.499016,-99) );
// itree = 783
fBoostWeights.push_back(0.00976349);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.541225,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.496105,-99) ,
9, -0.740417, 1, 0, 0.519874,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.53387,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.499871,-99) ,
3, 8.75156, 0, 0, 0.501119,-99) ,
NN(
0,
0,
-1, -0.412447, 1, -1, 0.469124,-99) ,
4, 0.999887, 0, 0, 0.498478,-99) ,
4, 0.999524, 1, 0, 0.499646,-99) );
// itree = 784
fBoostWeights.push_back(0.0407974);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.558121,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.490953,-99) ,
4, 0.999999, 0, 0, 0.507625,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.508651,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.462988,-99) ,
9, -0.0289242, 1, 0, 0.492416,-99) ,
4, 0.999977, 0, 0, 0.503245,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.481931,-99) ,
4, 0.999524, 0, 0, 0.502172,-99) );
// itree = 785
fBoostWeights.push_back(0.0201943);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.49809, 0, 1, 0.534118,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.530018,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.480167,-99) ,
9, -1.95115, 1, 0, 0.504445,-99) ,
9, -0.195175, 0, 0, 0.512457,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.531883,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.494893,-99) ,
9, 0.910841, 1, 0, 0.519448,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.501251,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.481026,-99) ,
8, -3.75773, 0, 0, 0.499271,-99) ,
0, 0.492376, 1, 0, 0.501247,-99) ,
7, -0.714306, 1, 0, 0.503833,-99) );
// itree = 786
fBoostWeights.push_back(0.0159184);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.922615, 0, 1, 0.531299,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.536888,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.499313,-99) ,
7, -1.76362, 1, 0, 0.501468,-99) ,
9, 0.451221, 0, 0, 0.503907,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.518674,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.491748,-99) ,
0, 0.502172, 1, 0, 0.503893,-99) ,
NN(
0,
0,
-1, -0.0715367, 0, -1, 0.483886,-99) ,
0, 0.499995, 0, 0, 0.490859,-99) ,
9, 0.745017, 1, 0, 0.500142,-99) );
// itree = 787
fBoostWeights.push_back(0.0113396);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.545413,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.513638,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.498896,-99) ,
7, 0.999999, 0, 0, 0.502089,-99) ,
4, 0.999048, 1, 0, 0.503351,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.472326,-99) ,
3, 9.38081, 1, 0, 0.502475,-99) );
// itree = 788
fBoostWeights.push_back(0.0183871);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -951.286, 0, 1, 0.528515,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.518771,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.489258,-99) ,
0, 0.504712, 0, 0, 0.509302,-99) ,
0, 0.503805, 1, 0, 0.518949,-99) ,
NN(
NN(
0,
0,
-1, 0.0298694, 0, 1, 0.525384,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.502283,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.481719,-99) ,
7, 1.57141, 1, 0, 0.500237,-99) ,
0, 0.491696, 1, 0, 0.502701,-99) ,
0, 0.5019, 0, 0, 0.505882,-99) );
// itree = 789
fBoostWeights.push_back(0.0173654);
fForest.push_back(
NN(
NN(
0,
0,
-1, -0.772213, 0, 1, 0.523129,-99) ,
NN(
NN(
0,
0,
-1, -0.877373, 1, 1, 0.505367,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.469442,-99) ,
8, -4.16772, 0, 0, 0.503041,-99) ,
7, -1.28552, 1, 0, 0.505139,-99) );
// itree = 790
fBoostWeights.push_back(0.0104383);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.564609, 0, 1, 0.502753,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.467216,-99) ,
9, 4.19777, 1, 0, 0.501563,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.451033,-99) ,
9, -2.52271, 0, 0, 0.499931,-99) );
// itree = 791
fBoostWeights.push_back(0.00806989);
fForest.push_back(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.532525,-99) ,
NN(
0,
0,
-1, -2.57238, 0, -1, 0.497184,-99) ,
7, 2.14285, 0, 0, 0.498633,-99) );
// itree = 792
fBoostWeights.push_back(0.012016);
fForest.push_back(
NN(
NN(
0,
0,
-1, 1.71185, 0, 1, 0.503288,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.508885,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.469923,-99) ,
3, 1.45611, 0, 0, 0.490046,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.455719,-99) ,
3, 4.12895, 1, 0, 0.482613,-99) ,
9, 2.06512, 1, 0, 0.500647,-99) );
// itree = 793
fBoostWeights.push_back(0.0202025);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -0.826318, 1, 1, 0.539427,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.502389,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.476052,-99) ,
5, 0.000485154, 0, 0, 0.499927,-99) ,
5, 0.0101874, 0, 0, 0.503151,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.38017,-99) ,
5, 0.0237713, 1, 0, 0.500051,-99) );
// itree = 794
fBoostWeights.push_back(0.0139859);
fForest.push_back(
NN(
NN(
0,
0,
-1, -951.286, 0, 1, 0.520821,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.50547,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.494833,-99) ,
3, 4.72382, 0, 0, 0.496899,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.480517,-99) ,
9, -2.26819, 0, 0, 0.49601,-99) ,
7, 1.85716, 0, 0, 0.497672,-99) );
// itree = 795
fBoostWeights.push_back(0.0228892);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.508957,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.49272,-99) ,
7, 0.428532, 1, 0, 0.502642,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.518663,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.46674,-99) ,
7, 0.428666, 0, 0, 0.48738,-99) ,
2, 0.0707112, 1, 0, 0.500468,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.509726,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.492016,-99) ,
7, -0.428435, 1, 0, 0.497918,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.502266,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.460275,-99) ,
6, -0.428528, 0, 0, 0.486563,-99) ,
6, -951.286, 1, 0, 0.492372,-99) ,
0, 0.496186, 0, 0, 0.497912,-99) );
// itree = 796
fBoostWeights.push_back(0.0185703);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.0575072, 0, 1, 0.521365,-99) ,
NN(
0,
0,
-1, 0.506214, 1, -1, 0.481058,-99) ,
0, 0.505164, 1, 0, 0.51067,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.516352,-99) ,
NN(
0,
0,
-1, -1.85692, 0, -1, 0.49422,-99) ,
9, 3.05633, 0, 0, 0.495716,-99) ,
0, 0.501899, 0, 0, 0.498647,-99) );
// itree = 797
fBoostWeights.push_back(0.011294);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.534054,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.53349,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.497725,-99) ,
7, 2.14288, 0, 0, 0.499102,-99) ,
4, 0.999524, 1, 0, 0.500882,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.473991,-99) ,
3, 9.33163, 1, 0, 0.500097,-99) );
// itree = 798
fBoostWeights.push_back(0.0193204);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.514857,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.497416,-99) ,
4, 0.999996, 0, 0, 0.505253,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.500168,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.454584,-99) ,
2, 0.0712014, 1, 0, 0.486725,-99) ,
4, 0.999909, 0, 0, 0.502959,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.459745,-99) ,
4, 0.999048, 0, 0, 0.501738,-99) );
// itree = 799
fBoostWeights.push_back(0.0107251);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -0.142658, 0, 1, 0.522544,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.512611,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.4989,-99) ,
2, 0.0714181, 0, 0, 0.501007,-99) ,
8, 0.619848, 0, 0, 0.502523,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.460996,-99) ,
9, 4.21549, 1, 0, 0.501198,-99) );
// itree = 800
fBoostWeights.push_back(0.0243198);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.51315,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.475586,-99) ,
7, -1.57125, 0, 0, 0.510467,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.503144,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.405732,-99) ,
6, -1.85725, 0, 0, 0.496115,-99) ,
6, -951.286, 1, 0, 0.503461,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.482639,-99) ,
4, 0.999524, 0, 0, 0.502434,-99) );
// itree = 801
fBoostWeights.push_back(0.0146686);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.538654,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.476935,-99) ,
7, -0.42839, 0, 0, 0.518681,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.519785,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.497475,-99) ,
7, -1.57125, 1, 0, 0.498933,-99) ,
8, -0.136976, 0, 0, 0.500751,-99) ,
NN(
0,
0,
-1, 2.64703, 1, -1, 0.479403,-99) ,
9, 3.09326, 1, 0, 0.49936,-99) );
// itree = 802
fBoostWeights.push_back(0.0251335);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.93372, 0, 1, 0.508358,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.478132,-99) ,
7, -1.57141, 0, 0, 0.506205,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.559827,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.496832,-99) ,
7, 1.5718, 0, 0, 0.502585,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.384049,-99) ,
6, -1.85712, 0, 0, 0.494265,-99) ,
6, -951.286, 1, 0, 0.500315,-99) );
// itree = 803
fBoostWeights.push_back(0.0284493);
fForest.push_back(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.523454,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.512327,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.409631,-99) ,
6, -1.85725, 0, 0, 0.504973,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.505694,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.487694,-99) ,
7, 0.428691, 0, 0, 0.494801,-99) ,
6, -951.286, 0, 0, 0.49986,-99) ,
0, 0.490472, 1, 0, 0.500927,-99) );
// itree = 804
fBoostWeights.push_back(0.017056);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.508297,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.484959,-99) ,
7, 1.28571, 1, 0, 0.50512,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.509918,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.493791,-99) ,
2, -0.0701876, 1, 0, 0.496453,-99) ,
0, 0.499043, 0, 0, 0.500108,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.500463,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.456209,-99) ,
3, 1.70162, 0, 0, 0.482144,-99) ,
9, 3.05633, 1, 0, 0.498925,-99) );
// itree = 805
fBoostWeights.push_back(0.0141239);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.49809, 1, 1, 0.51922,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.502616,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.453264,-99) ,
9, -2.16975, 0, 0, 0.500622,-99) ,
7, -1.57132, 1, 0, 0.501929,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.501533,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.483179,-99) ,
0, 0.500538, 0, 0, 0.491854,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.465175,-99) ,
0, 0.496185, 0, 0, 0.483427,-99) ,
9, 1.99143, 1, 0, 0.499454,-99) );
// itree = 806
fBoostWeights.push_back(0.0210577);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.541085,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.492894,-99) ,
3, 2.77018, 1, 0, 0.518339,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.507392,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.494305,-99) ,
2, -0.00859773, 1, 0, 0.500103,-99) ,
2, 0.0656142, 0, 0, 0.502521,-99) ,
NN(
0,
0,
-1, -0.0716195, 0, -1, 0.48256,-99) ,
3, 4.73378, 1, 0, 0.498742,-99) );
// itree = 807
fBoostWeights.push_back(0.0150854);
fForest.push_back(
NN(
NN(
0,
0,
-1, 0.497138, 1, 1, 0.523625,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.529839,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.495734,-99) ,
7, 2.12929, 0, 0, 0.497213,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.45678,-99) ,
4, 0.999048, 0, 0, 0.496071,-99) ,
7, -1.57125, 1, 0, 0.497831,-99) );
// itree = 808
fBoostWeights.push_back(0.0196768);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 1.7062, 0, 1, 0.52472,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.504097,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.473575,-99) ,
7, 0.730516, 0, 0, 0.489786,-99) ,
6, -951.286, 1, 0, 0.511384,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.529134,-99) ,
NN(
0,
0,
-1, 0.999909, 0, -1, 0.495989,-99) ,
4, 0.999048, 1, 0, 0.497275,-99) ,
9, 0.71673, 0, 0, 0.501591,-99) );
// itree = 809
fBoostWeights.push_back(0.0179373);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.507554,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.489217,-99) ,
7, -1.57124, 0, 0, 0.506362,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.476704,-99) ,
4, 0.999048, 0, 0, 0.505438,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.504257,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.474639,-99) ,
0, 0.499991, 0, 0, 0.485469,-99) ,
9, 2.84504, 1, 0, 0.503908,-99) );
// itree = 810
fBoostWeights.push_back(0.00988582);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.543731,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.497482,-99) ,
1, -0.000627221, 0, 0, 0.523642,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.529221,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.498747,-99) ,
3, 8.84402, 0, 0, 0.49985,-99) ,
0, 0.491424, 1, 0, 0.501452,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.456797,-99) ,
4, 0.999048, 0, 0, 0.500214,-99) );
// itree = 811
fBoostWeights.push_back(0.0127837);
fForest.push_back(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.520152,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.509138,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.496441,-99) ,
8, -1.31682, 0, 0, 0.498664,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.504297,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.472306,-99) ,
9, 2.53366, 1, 0, 0.483626,-99) ,
9, 2.19189, 1, 0, 0.497536,-99) ,
8, 2.07299, 0, 0, 0.498689,-99) );
// itree = 812
fBoostWeights.push_back(0.0135795);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.546529,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.501074,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.477928,-99) ,
9, 3.50693, 1, 0, 0.500005,-99) ,
4, 0.999048, 1, 0, 0.501423,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.510712,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.519621,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.420064,-99) ,
6, -951.286, 1, 0, 0.467316,-99) ,
8, -0.772849, 0, 0, 0.481929,-99) ,
7, 1.5715, 1, 0, 0.499493,-99) );
// itree = 813
fBoostWeights.push_back(0.0150601);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -951.286, 0, 1, 0.517902,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.500209,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.466522,-99) ,
0, 0.502126, 1, 0, 0.498734,-99) ,
0, 0.502852, 0, 0, 0.50144,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.514427,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.489657,-99) ,
3, 1.62828, 0, 0, 0.504364,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.514803,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.447208,-99) ,
6, -951.287, 0, 0, 0.473626,-99) ,
7, 0.429691, 1, 0, 0.487187,-99) ,
9, 1.74667, 1, 0, 0.499215,-99) );
// itree = 814
fBoostWeights.push_back(0.0172341);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 1.52182, 0, 1, 0.506514,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.501403,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.401091,-99) ,
6, -1.85716, 0, 0, 0.494147,-99) ,
6, -951.286, 1, 0, 0.500404,-99) ,
NN(
0,
0,
-1, -0.0733765, 0, -1, 0.486519,-99) ,
0, 0.5019, 1, 0, 0.497763,-99) );
// itree = 815
fBoostWeights.push_back(0.012364);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.525805,-99) ,
NN(
0,
0,
-1, 2.14286, 1, -1, 0.495597,-99) ,
9, 2.40675, 0, 0, 0.497017,-99) ,
NN(
0,
0,
-1, 0.498094, 0, -1, 0.481734,-99) ,
9, 3.23131, 1, 0, 0.496098,-99) );
// itree = 816
fBoostWeights.push_back(0.0173205);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.554889,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.536628,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.491911,-99) ,
7, 1.44898, 1, 0, 0.501516,-99) ,
1, -0.00345143, 1, 0, 0.512939,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.5321,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.495679,-99) ,
9, -1.83008, 1, 0, 0.511137,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.500773,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.471038,-99) ,
9, 3.15787, 1, 0, 0.498836,-99) ,
7, -0.755146, 1, 0, 0.501974,-99) ,
7, 1.28571, 0, 0, 0.503668,-99) );
// itree = 817
fBoostWeights.push_back(0.0141071);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.0460272, 0, 1, 0.506607,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.472941,-99) ,
8, 0.253058, 1, 0, 0.503403,-99) ,
NN(
0,
0,
-1, -1.13257, 0, -1, 0.493989,-99) ,
7, -0.142873, 1, 0, 0.49785,-99) );
// itree = 818
fBoostWeights.push_back(0.0242627);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -951.286, 1, 1, 0.537134,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.520082,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.495093,-99) ,
8, 0.24714, 0, 0, 0.497746,-99) ,
5, 0.00905547, 0, 0, 0.501951,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.397813,-99) ,
5, 0.0237713, 1, 0, 0.499312,-99) );
// itree = 819
fBoostWeights.push_back(0.0176787);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.544203,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.510531,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.474573,-99) ,
0, 0.505679, 0, 0, 0.495837,-99) ,
0, 0.504711, 1, 0, 0.512984,-99) ,
NN(
NN(
0,
0,
-1, -3.38086, 1, 1, 0.505094,-99) ,
NN(
0,
0,
-1, 2.44605, 1, -1, 0.492178,-99) ,
0, 0.496095, 1, 0, 0.496656,-99) ,
0, 0.503804, 0, 0, 0.498297,-99) );
// itree = 820
fBoostWeights.push_back(0.0117264);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.550305,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.528555,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.492329,-99) ,
7, 1.9116, 1, 0, 0.507879,-99) ,
1, 0.00152331, 0, 0, 0.523731,-99) ,
NN(
NN(
0,
0,
-1, -4.29433, 1, 1, 0.50129,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.501139,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.455583,-99) ,
7, 0.047892, 1, 0, 0.480559,-99) ,
0, 0.503804, 1, 0, 0.499325,-99) ,
7, 1.57141, 0, 0, 0.501883,-99) );
// itree = 821
fBoostWeights.push_back(0.0109204);
fForest.push_back(
NN(
NN(
0,
0,
-1, 2.12928, 1, 1, 0.523967,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.501707,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.476414,-99) ,
0, 0.490472, 0, 0, 0.500623,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.473235,-99) ,
9, 3.05633, 1, 0, 0.49894,-99) ,
7, 1.85718, 0, 0, 0.500621,-99) );
// itree = 822
fBoostWeights.push_back(0.0132963);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.509972,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.497033,-99) ,
8, -3.68688, 1, 0, 0.498881,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.460441,-99) ,
9, -2.13247, 0, 0, 0.496958,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.467869,-99) ,
7, -1.85684, 0, 0, 0.495965,-99) );
// itree = 823
fBoostWeights.push_back(0.0130574);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.0462014, 0, 1, 0.52674,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.490152,-99) ,
3, 4.18018, 1, 0, 0.51688,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.521679,-99) ,
NN(
0,
0,
-1, -0.0714192, 0, -1, 0.496838,-99) ,
7, 2.14284, 0, 0, 0.49785,-99) ,
0, 0.502852, 0, 0, 0.500571,-99) );
// itree = 824
fBoostWeights.push_back(0.0149282);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.548844,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.489687,-99) ,
8, -1.80319, 1, 0, 0.526281,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.528086,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.497081,-99) ,
0, 0.490472, 1, 0, 0.498526,-99) ,
3, 0.557533, 1, 0, 0.500857,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.463096,-99) ,
3, 9.39171, 1, 0, 0.499801,-99) );
// itree = 825
fBoostWeights.push_back(0.00947841);
fForest.push_back(
NN(
NN(
0,
0,
-1, -0.958746, 0, 1, 0.517288,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.541242,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.498028,-99) ,
8, -0.72464, 0, 0, 0.507297,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.500549,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.488133,-99) ,
0, 0.502852, 1, 0, 0.498931,-99) ,
2, 0.0713805, 0, 0, 0.5002,-99) ,
7, -1.28572, 1, 0, 0.501965,-99) );
// itree = 826
fBoostWeights.push_back(0.0134826);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -1.39453, 1, 1, 0.505272,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.473144,-99) ,
9, -2.1661, 0, 0, 0.503745,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.480738,-99) ,
7, -1.85713, 0, 0, 0.502958,-99) );
// itree = 827
fBoostWeights.push_back(0.00945404);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.528298,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.527387,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.498441,-99) ,
7, 2.14288, 0, 0, 0.499575,-99) ,
4, 0.999524, 1, 0, 0.50102,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.465854,-99) ,
3, 9.37272, 1, 0, 0.500018,-99) );
// itree = 828
fBoostWeights.push_back(0.00745148);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.52839,-99) ,
NN(
0,
0,
-1, 0.999819, 0, -1, 0.498191,-99) ,
4, 0.999048, 1, 0, 0.499099,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.471077,-99) ,
0, 0.490472, 0, 0, 0.497909,-99) );
// itree = 829
fBoostWeights.push_back(0.0117778);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.553253,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.502878,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.477831,-99) ,
3, 6.84652, 1, 0, 0.501593,-99) ,
4, 0.999048, 1, 0, 0.50313,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.478895,-99) ,
3, 8.95163, 1, 0, 0.502282,-99) );
// itree = 830
fBoostWeights.push_back(0.0139401);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -1.10618, 0, 1, 0.524667,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.489701,-99) ,
0, 0.500947, 1, 0, 0.515977,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.505666,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.496111,-99) ,
7, 0.755202, 0, 0, 0.499172,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.471716,-99) ,
0, 0.505709, 1, 0, 0.498189,-99) ,
7, -1.28549, 1, 0, 0.500057,-99) );
// itree = 831
fBoostWeights.push_back(0.0264332);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -3.47182, 0, 1, 0.516124,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.521594,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.486871,-99) ,
9, 1.52717, 0, 0, 0.495444,-99) ,
9, -1.07812, 1, 0, 0.505559,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.504674,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.48141,-99) ,
7, 0.402011, 0, 0, 0.49927,-99) ,
NN(
0,
0,
-1, -951.286, 0, -1, 0.479608,-99) ,
7, 1.5034, 1, 0, 0.494927,-99) ,
7, 0.142861, 1, 0, 0.50035,-99) );
// itree = 832
fBoostWeights.push_back(0.0146346);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.560234,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.492806,-99) ,
6, -951.286, 1, 0, 0.529174,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.51681,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.48347,-99) ,
6, -951.286, 0, 0, 0.500207,-99) ,
0, 0.499995, 0, 0, 0.510997,-99) ,
NN(
NN(
0,
0,
-1, 0.999524, 1, 1, 0.502291,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.500453,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.480593,-99) ,
8, 0.257493, 0, 0, 0.490228,-99) ,
9, 0.969131, 1, 0, 0.499214,-99) ,
2, 0.0709021, 0, 0, 0.501032,-99) );
// itree = 833
fBoostWeights.push_back(0.0174113);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.518488,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.49997,-99) ,
2, -0.0723171, 1, 0, 0.503004,-99) ,
NN(
0,
0,
-1, -1.47524, 0, -1, 0.491212,-99) ,
0, 0.499043, 1, 0, 0.498112,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.50692,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.483224,-99) ,
0, 0.501898, 0, 0, 0.488356,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.448785,-99) ,
7, -0.99982, 0, 0, 0.483746,-99) ,
8, -1.14454, 1, 0, 0.494622,-99) );
// itree = 834
fBoostWeights.push_back(0.0109763);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.539207,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.518838,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.494,-99) ,
0, 0.498092, 0, 0, 0.506978,-99) ,
7, 1.91163, 1, 0, 0.520728,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.53842,-99) ,
NN(
0,
0,
-1, 0.999637, 0, -1, 0.497738,-99) ,
4, 0.999048, 1, 0, 0.498956,-99) ,
7, 1.57142, 0, 0, 0.501214,-99) );
// itree = 835
fBoostWeights.push_back(0.0167099);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0.429291, 0, 1, 0.529385,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.510338,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.496526,-99) ,
9, 1.62718, 1, 0, 0.507905,-99) ,
2, 0.0709779, 0, 0, 0.511386,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.501742,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.460653,-99) ,
4, 0.999841, 0, 0, 0.499314,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.468179,-99) ,
4, 0.999524, 0, 0, 0.497751,-99) ,
0, 0.499043, 0, 0, 0.503538,-99) );
// itree = 836
fBoostWeights.push_back(0.014422);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.522917,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.50601,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.496293,-99) ,
9, -0.108208, 1, 0, 0.501565,-99) ,
0, 0.505709, 0, 0, 0.502387,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.450004,-99) ,
7, 2.14285, 1, 0, 0.500541,-99) );
// itree = 837
fBoostWeights.push_back(0.0193427);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.529638,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.507672,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.484582,-99) ,
7, -0.673315, 0, 0, 0.505537,-99) ,
7, -1.28555, 1, 0, 0.507099,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.521706,-99) ,
NN(
0,
0,
-1, 0.272726, 1, -1, 0.492441,-99) ,
9, -0.721452, 0, 0, 0.496462,-99) ,
8, -3.01661, 0, 0, 0.503243,-99) );
// itree = 838
fBoostWeights.push_back(0.0165428);
fForest.push_back(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.527896,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.52313,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.499384,-99) ,
7, -0.551021, 0, 0, 0.502321,-99) ,
NN(
0,
0,
-1, 1.17522, 1, -1, 0.490656,-99) ,
7, -0.428564, 1, 0, 0.49432,-99) ,
2, 0.213864, 0, 0, 0.495625,-99) );
// itree = 839
fBoostWeights.push_back(0.00780945);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.550397,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.500035,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.477292,-99) ,
9, -2.5095, 0, 0, 0.499212,-99) ,
8, 0.89989, 0, 0, 0.50089,-99) ,
NN(
0,
0,
-1, 2.1798, 0, -1, 0.472226,-99) ,
9, 3.27805, 1, 0, 0.499277,-99) );
// itree = 840
fBoostWeights.push_back(0.0227024);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -4.17377, 0, 1, 0.524656,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.506753,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.475538,-99) ,
2, -0.0472851, 0, 0, 0.499836,-99) ,
9, -1.56394, 1, 0, 0.512319,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.510245,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.492868,-99) ,
0, 0.500947, 0, 0, 0.497403,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.461699,-99) ,
7, 2.11569, 1, 0, 0.495635,-99) ,
7, -0.714121, 1, 0, 0.499474,-99) );
// itree = 841
fBoostWeights.push_back(0.0193786);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.509132,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.494344,-99) ,
9, -1.69167, 0, 0, 0.507092,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.487326,-99) ,
9, 3.14527, 1, 0, 0.505923,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.509272,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.491356,-99) ,
9, 1.54212, 1, 0, 0.503151,-99) ,
NN(
0,
0,
-1, 0.196087, 1, -1, 0.484007,-99) ,
8, -2.70685, 0, 0, 0.494992,-99) ,
0, 0.500947, 1, 0, 0.503131,-99) );
// itree = 842
fBoostWeights.push_back(0.0282387);
fForest.push_back(
NN(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.513275,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.493758,-99) ,
8, -0.541537, 1, 0, 0.509787,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.509564,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.481692,-99) ,
2, -0.0106624, 1, 0, 0.496869,-99) ,
2, 0.00358361, 0, 0, 0.503639,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.528451,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.487154,-99) ,
8, -2.20415, 1, 0, 0.505969,-99) ,
NN(
0,
0,
-1, -0.9862, 1, -1, 0.47782,-99) ,
7, 0.143853, 0, 0, 0.491495,-99) ,
2, -0.0712075, 0, 0, 0.501647,-99) );
// itree = 843
fBoostWeights.push_back(0.0234262);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 4.73982, 0, 1, 0.511053,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.505905,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.48346,-99) ,
0, 0.502673, 0, 0, 0.497343,-99) ,
0, 0.501129, 1, 0, 0.505492,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.505772,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.485144,-99) ,
6, -951.286, 1, 0, 0.495749,-99) ,
NN(
0,
0,
-1, -951.286, 0, -1, 0.472751,-99) ,
3, 4.59366, 1, 0, 0.491443,-99) ,
0, 0.497138, 0, 0, 0.499912,-99) );
// itree = 844
fBoostWeights.push_back(0.00912034);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.540523,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.525777,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.498599,-99) ,
7, 2.14284, 0, 0, 0.499666,-99) ,
3, 9.12912, 0, 0, 0.500991,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.462435,-99) ,
4, 0.999048, 0, 0, 0.499895,-99) );
// itree = 845
fBoostWeights.push_back(0.0225928);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, -1.71282, 0, 1, 0.522286,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.480764,-99) ,
9, -2.49116, 0, 0, 0.5125,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.502689,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.486506,-99) ,
9, 2.36381, 1, 0, 0.500409,-99) ,
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.54438,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.459334,-99) ,
8, -3.36862, 0, 0, 0.484484,-99) ,
9, -1.0565, 0, 0, 0.498132,-99) ,
8, -3.9435, 1, 0, 0.500186,-99) );
// itree = 846
fBoostWeights.push_back(0.0281877);
fForest.push_back(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.519102,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.51169,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.404952,-99) ,
6, -1.85727, 0, 0, 0.503909,-99) ,
NN(
0,
0,
-1, 2.4796, 1, -1, 0.490178,-99) ,
6, -951.286, 0, 0, 0.497033,-99) ,
8, 1.74434, 0, 0, 0.498287,-99) );
// itree = 847
fBoostWeights.push_back(0.0185962);
fForest.push_back(
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.523553,-99) ,
NN(
0,
0,
-1, 0.999637, 0, -1, 0.492192,-99) ,
2, 0.214101, 0, 0, 0.4932,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.456533,-99) ,
4, 0.999048, 0, 0, 0.492174,-99) );
// itree = 848
fBoostWeights.push_back(0.0135418);
fForest.push_back(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.538913,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.502708,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.474241,-99) ,
7, -1.28554, 0, 0, 0.500571,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.473953,-99) ,
9, -2.54011, 0, 0, 0.499711,-99) ,
8, 2.17642, 0, 0, 0.501607,-99) );
// itree = 849
fBoostWeights.push_back(0.00990949);
fForest.push_back(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.524356,-99) ,
NN(
NN(
NN(
0,
0,
-1, 0, 1, 1, 0.510488,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.498516,-99) ,
2, 0.0714181, 0, 0, 0.500362,-99) ,
NN(
0,
0,
-1, 0, 1, -1, 0.47459,-99) ,
9, 2.54816, 1, 0, 0.499282,-99) ,
8, 1.83707, 0, 0, 0.500671,-99) );
return;
};
// Clean up
inline void ReadBDT_LHC19c2b_6_8_noPCts::Clear()
{
for (unsigned int itree=0; itree<fForest.size(); itree++) {
delete fForest[itree];
}
}
inline double ReadBDT_LHC19c2b_6_8_noPCts::GetMvaValue( const std::vector<double>& inputValues ) const
{
// classifier response value
double retval = 0;
// classifier response, sanity check first
if (!IsStatusClean()) {
std::cout << "Problem in class \"" << fClassName << "\": cannot return classifier response"
<< " because status is dirty" << std::endl;
retval = 0;
}
else {
retval = GetMvaValue__( inputValues );
}
return retval;
}
// Added by ALICE analyzer
extern "C"
{
ReadBDT_LHC19c2b_6_8_noPCts *ReadBDT_maker_LHC19c2b_6_8_noPCts(std::vector<std::string> theInpVar)
{
return new ReadBDT_LHC19c2b_6_8_noPCts(theInpVar);
}
}
|
// Copyright (c) 2019 by Robert Bosch GmbH. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include "iceoryx_posh/roudi/memory/memory_block.hpp"
#include "mocks/roudi_memory_provider_mock.hpp"
#include "test.hpp"
using namespace ::testing;
using namespace iox::roudi;
class MemoryBlockTestImpl final : public MemoryBlock
{
public:
uint64_t size() const noexcept override
{
return MEMORY_SIZE;
}
uint64_t alignment() const noexcept override
{
return MEMORY_ALIGNMENT;
}
void destroy() noexcept override
{
}
static constexpr uint64_t MEMORY_SIZE = 1;
static constexpr uint64_t MEMORY_ALIGNMENT = 1;
};
class MemoryBlock_Test : public Test
{
public:
void SetUp() override
{
}
void TearDown() override
{
}
MemoryBlockTestImpl sut;
MemoryProviderTestImpl memoryProvider;
};
TEST_F(MemoryBlock_Test, Initial)
{
EXPECT_THAT(sut.memory().has_value(), Eq(false));
}
TEST_F(MemoryBlock_Test, MemoryAvailableAfterCreation)
{
memoryProvider.addMemoryBlock(&sut);
memoryProvider.create();
EXPECT_THAT(memoryProvider.dummyMemory, Ne(nullptr));
ASSERT_THAT(sut.memory().has_value(), Eq(true));
EXPECT_THAT(sut.memory().value(), Eq(memoryProvider.dummyMemory));
}
|
; A084104: A period 6 sequence.
; 1,4,7,7,4,1,1,4,7,7,4,1,1,4,7,7,4,1,1,4,7,7,4,1,1,4,7,7,4,1,1,4,7,7,4,1,1,4,7,7,4,1,1,4,7,7,4,1,1,4,7,7,4,1,1,4,7,7,4,1,1,4,7,7,4,1,1,4,7,7,4,1,1,4,7,7,4,1,1,4,7,7,4,1,1,4,7,7,4,1,1,4,7,7,4,1,1,4,7,7,4,1,1,4,7
mod $0,6
lpb $0
mul $0,4
mod $0,5
lpe
mov $1,$0
mul $1,3
add $1,1
|
;--------------------------------------------------------
; File Created by SDCC : FreeWare ANSI-C Compiler
; Version 2.3.1 Sat Apr 16 13:54:03 2011
;--------------------------------------------------------
.module gprintln
;--------------------------------------------------------
; Public variables in this module
;--------------------------------------------------------
.globl _gprintln
;--------------------------------------------------------
; special function registers
;--------------------------------------------------------
;--------------------------------------------------------
; special function bits
;--------------------------------------------------------
;--------------------------------------------------------
; internal ram data
;--------------------------------------------------------
.area _DATA
;--------------------------------------------------------
; overlayable items in internal ram
;--------------------------------------------------------
.area _OVERLAY
;--------------------------------------------------------
; indirectly addressable internal ram data
;--------------------------------------------------------
.area _ISEG
;--------------------------------------------------------
; bit data
;--------------------------------------------------------
.area _BSEG
;--------------------------------------------------------
; external ram data
;--------------------------------------------------------
.area _XSEG
;--------------------------------------------------------
; global & static initialisations
;--------------------------------------------------------
.area _GSINIT
.area _GSFINAL
.area _GSINIT
;--------------------------------------------------------
; Home
;--------------------------------------------------------
.area _HOME
.area _CODE
;--------------------------------------------------------
; code
;--------------------------------------------------------
.area _CODE
; gprintln.c 7
; genLabel
; genFunction
; ---------------------------------
; Function gprintln
; ---------------------------------
___gprintln_start:
_gprintln:
lda sp,-4(sp)
; gprintln.c 11
; genCmpLt
; AOP_STK for
lda hl,7(sp)
ld a,(hl)
bit 7,a
jp z,00102$
; genIfx
; AOP_STK for
xor a,a
inc hl
inc hl
or a,(hl)
jp z,00102$
; gprintln.c 12
; genIpush
; _saveRegsForCall: sendSetSize: 0 deInUse: 0 bcInUse: 0 deSending: 0
ld a,#0x2D
push af
inc sp
; genCall
call _wrtchr
lda sp,1(sp)
; gprintln.c 13
; genUminus
; AOP_STK for
xor a,a
lda hl,6(sp)
ld a,#0x00
sbc a,(hl)
ld (hl+),a
ld a,#0x00
sbc a,(hl)
ld (hl),a
; genLabel
00102$:
; gprintln.c 15
; genAssign
; (operands are equal 3)
; genCast
; AOP_STK for
; AOP_STK for _gprintln_sloc0_1_0
lda hl,8(sp)
ld a,(hl)
lda hl,0(sp)
ld (hl+),a
ld (hl),#0x00
; genIpush
; _saveRegsForCall: sendSetSize: 0 deInUse: 0 bcInUse: 0 deSending: 0
; AOP_STK for _gprintln_sloc0_1_0
dec hl
ld a,(hl+)
ld h,(hl)
ld l,a
push hl
; genIpush
; AOP_STK for
lda hl,8(sp)
ld a,(hl+)
ld h,(hl)
ld l,a
push hl
; genCall
call __divuint_rrx_s
ld b,d
ld c,e
lda sp,4(sp)
; genAssign
; AOP_STK for _gprintln_l_1_1
lda hl,2(sp)
ld (hl),c
inc hl
ld (hl),b
; genCmpEq
; genCmpEq: left 2, right 2, result 0
ld a,c
or a,b
jp z,00105$
00111$:
; gprintln.c 16
; genAssign
; AOP_STK for _gprintln_l_1_1
lda hl,2(sp)
ld c,(hl)
inc hl
ld b,(hl)
; genIpush
; _saveRegsForCall: sendSetSize: 0 deInUse: 0 bcInUse: 0 deSending: 0
ld a,#0x00
push af
inc sp
; genIpush
; AOP_STK for
lda hl,9(sp)
ld a,(hl)
push af
inc sp
; genIpush
push bc
; genCall
call _gprintln
lda sp,4(sp)
; genLabel
00105$:
; gprintln.c 17
; genAssign
; AOP_STK for
lda hl,6(sp)
ld c,(hl)
inc hl
ld b,(hl)
; genIpush
; _saveRegsForCall: sendSetSize: 0 deInUse: 0 bcInUse: 0 deSending: 0
; AOP_STK for _gprintln_sloc0_1_0
lda hl,0(sp)
ld a,(hl+)
ld h,(hl)
ld l,a
push hl
; genIpush
push bc
; genCall
call __moduint_rrx_s
ld b,d
ld c,e
lda sp,4(sp)
; genPlus
; AOP_HL for _digits
; Can't optimise plus by inc, falling back to the normal way
ld hl,#_digits
ld a,(hl)
add a,c
ld c,a
inc hl
ld a,(hl)
adc a,b
ld b,a
; genPointerGet
ld a,(bc)
; genIpush
; _saveRegsForCall: sendSetSize: 0 deInUse: 0 bcInUse: 0 deSending: 0
ld c,a
push af
inc sp
; genCall
call _wrtchr
lda sp,1(sp)
; genLabel
00106$:
; genEndFunction
lda sp,4(sp)
ret
___gprintln_end:
.area _CODE
|
; A347275: a(n) is the number of nonnegative ordered pairs (a,b) satisfying (a+b <= n) and (a*b <= n)
; Submitted by Jamie Morken(s2)
; 1,3,6,10,15,19,25,29,35,40,46,50,58,62,68,74,81,85,93,97,105,111,117,121,131,136,142,148,156,160,170,174,182,188,194,200,211,215,221,227,237,241,251,255,263,271,277,281,293,298,306,312,320,324,334,340,350,356
mov $1,$0
seq $1,54519 ; Number of increasing arithmetic progressions of nonnegative integers ending in n, including those of length 1 or 2.
mov $2,$0
add $0,$1
trn $2,2
add $0,$2
|
; A183002: Partial sums of A161840.
; 0,0,0,2,2,4,4,6,8,10,10,14,14,16,18,22,22,26,26,30,32,34,34,40,42,44,46,50,50,56,56,60,62,64,66,74,74,76,78,84,84,90,90,94,98,100,100,108,110,114,116,120,120,126,128,134,136,138,138
mov $10,$0
mov $12,$0
lpb $12,1
mov $0,$10
sub $12,1
sub $0,$12
mov $6,$0
mov $8,2
lpb $8,1
clr $0,6
mov $0,$6
sub $8,1
add $0,$8
sub $0,1
lpb $0,1
mov $1,$0
sub $0,1
add $3,1
div $1,$3
add $5,$1
lpe
mov $1,$5
mov $9,$8
lpb $9,1
mov $7,$1
sub $9,1
lpe
lpe
lpb $6,1
mov $6,0
sub $7,$1
lpe
mov $1,$7
mul $1,2
div $1,4
mul $1,2
add $11,$1
lpe
mov $1,$11
|
; A021590: Decimal expansion of 1/586.
; Submitted by Jon Maiga
; 0,0,1,7,0,6,4,8,4,6,4,1,6,3,8,2,2,5,2,5,5,9,7,2,6,9,6,2,4,5,7,3,3,7,8,8,3,9,5,9,0,4,4,3,6,8,6,0,0,6,8,2,5,9,3,8,5,6,6,5,5,2,9,0,1,0,2,3,8,9,0,7,8,4,9,8,2,9,3,5,1,5,3,5,8,3,6,1,7,7,4,7,4,4,0,2,7,3,0,3
add $0,1
mov $2,10
pow $2,$0
div $2,586
mov $0,$2
mod $0,10
|
assume cs:code
code segment
mov ax,0ffffh
mov ds,ax
mov bx,6
mov al,[bx] ; use mov al,[6] instead??
mov ah,0
mov dx,0
mov cx,3
s: add dx,ax
loop s
mov ax,4c00h
int 21h
code ends
end
|
/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
==============================================================================*/
// See docs in ../ops/io_ops.cc.
#include <memory>
#include "tensorflow/core/framework/reader_op_kernel.h"
#include "tensorflow/core/kernels/reader_base.h"
#include "tensorflow/core/lib/core/errors.h"
#include "tensorflow/core/lib/io/inputbuffer.h"
#include "tensorflow/core/lib/strings/strcat.h"
#include "tensorflow/core/platform/env.h"
namespace tensorflow {
class TextLineReader : public ReaderBase {
public:
TextLineReader(const string& node_name, int skip_header_lines, Env* env)
: ReaderBase(strings::StrCat("TextLineReader '", node_name, "'")),
skip_header_lines_(skip_header_lines),
env_(env),
line_number_(0) {}
Status OnWorkStartedLocked() override {
line_number_ = 0;
TF_RETURN_IF_ERROR(env_->NewRandomAccessFile(current_work(), &file_));
input_buffer_.reset(new io::InputBuffer(file_.get(), kBufferSize));
for (; line_number_ < skip_header_lines_; ++line_number_) {
string line_contents;
Status status = input_buffer_->ReadLine(&line_contents);
if (errors::IsOutOfRange(status)) {
// We ignore an end of file error when skipping header lines.
// We will end up skipping this file.
return Status::OK();
}
TF_RETURN_IF_ERROR(status);
}
return Status::OK();
}
Status OnWorkFinishedLocked() override {
input_buffer_.reset(nullptr);
return Status::OK();
}
Status ReadLocked(string* key, string* value, bool* produced,
bool* at_end) override {
Status status = input_buffer_->ReadLine(value);
++line_number_;
if (status.ok()) {
*key = strings::StrCat(current_work(), ":", line_number_);
*produced = true;
return status;
}
if (errors::IsOutOfRange(status)) { // End of file, advance to the next.
*at_end = true;
return Status::OK();
} else { // Some other reading error
return status;
}
}
Status ResetLocked() override {
line_number_ = 0;
input_buffer_.reset(nullptr);
return ReaderBase::ResetLocked();
}
// TODO(josh11b): Implement serializing and restoring the state. Need
// to create TextLineReaderState proto to store ReaderBaseState,
// line_number_, and input_buffer_->Tell().
private:
enum { kBufferSize = 256 << 10 /* 256 kB */ };
const int skip_header_lines_;
Env* const env_;
int64 line_number_;
std::unique_ptr<RandomAccessFile> file_; // must outlive input_buffer_
std::unique_ptr<io::InputBuffer> input_buffer_;
};
class TextLineReaderOp : public ReaderOpKernel {
public:
explicit TextLineReaderOp(OpKernelConstruction* context)
: ReaderOpKernel(context) {
int skip_header_lines = -1;
OP_REQUIRES_OK(context,
context->GetAttr("skip_header_lines", &skip_header_lines));
OP_REQUIRES(context, skip_header_lines >= 0,
errors::InvalidArgument("skip_header_lines must be >= 0 not ",
skip_header_lines));
Env* env = context->env();
SetReaderFactory([this, skip_header_lines, env]() {
return new TextLineReader(name(), skip_header_lines, env);
});
}
};
REGISTER_KERNEL_BUILDER(Name("TextLineReader").Device(DEVICE_CPU),
TextLineReaderOp);
REGISTER_KERNEL_BUILDER(Name("TextLineReaderV2").Device(DEVICE_CPU),
TextLineReaderOp);
} // namespace tensorflow
|
%define BE(a) ( ((((a)>>24)&0xFF) << 0) + ((((a)>>16)&0xFF) << 8) + ((((a)>>8)&0xFF) << 16) + ((((a)>>0)&0xFF) << 24) )
ftyp_start:
dd BE(ftyp_end - ftyp_start)
db "ftyp"
db "isom"
dd BE(0x00)
db "mif1", "miaf"
ftyp_end:
meta_start:
dd BE(meta_end - meta_start)
db "meta"
dd BE(0)
hdlr_start:
dd BE(hdlr_end - hdlr_start)
db "hdlr"
db 0x00 ; version(8)
db 0x00, 0x00, 0x00 ; flags(24)
db 0x00, 0x00, 0x00, 0x00 ; pre_defined(32)
db 0x70, 0x69, 0x63, 0x74 ; handler_type(32) ('pict')
db 0x00, 0x00, 0x00, 0x00 ; reserved1(32)
db 0x00, 0x00, 0x00, 0x00 ; reserved2(32)
db 0x00, 0x00, 0x00, 0x00 ; reserved3(32)
db 0x00 ; name(8)
hdlr_end:
pitm_start:
dd BE(pitm_end - pitm_start)
db "pitm"
dd BE(0)
db 0xaa, 0xbb
pitm_end:
iinf_start:
dd BE(iinf_end - iinf_start)
db "iinf"
dd BE(0)
db 0x00, 0x00
iinf_end:
iloc_start:
dd BE(iloc_end - iloc_start)
db "iloc"
dd BE(0x01000000)
dd BE(1) ; 1 item
dd BE(0) ; construction_method
db 0, 1 ; invalid data_reference_index
dw BE(0)
iloc_end:
iref_start:
dd BE(iref_end - iref_start)
db "iref"
dd BE(0)
iref_end:
iprp_start:
dd BE(iprp_end - iprp_start)
db "iprp"
ipco_start:
dd BE(ipco_end - ipco_start)
db "ipco"
ispe_start:
dd BE(ispe_end - ispe_start)
db "ispe"
dd 0, 0, 0
ispe_end:
ipco_end:
iprp_end:
meta_end:
; vim: syntax=nasm
|
; 04.2004 aralbrec
SECTION code_clib
PUBLIC IM2RemoveHook
PUBLIC _IM2RemoveHook
EXTERN _im2_hookDisp
; enter: de = address of hook (subroutine)
; l = interrupt vector where Generic ISR is installed
; used : af, bc, de, hl
; exit : carry = hook found and removed
; no carry = hook not found
.IM2RemoveHook
._IM2RemoveHook
ld a,i
ld h,a
ld c,(hl)
inc hl
ld b,(hl)
ld hl,_im2_hookDisp - 1
add hl,bc ; hl points at hooks list-1
.search
inc hl
ld c,(hl)
inc hl
ld b,(hl) ; bc = a hook address
ld a,b
or c
ret z ; ret nc, failed to find it
ld a,c
cp e
jp nz, search
ld a,b
cp d
jp nz, search
ld e,l ; found hook so remove it
ld d,h
dec de
inc hl
.remove
ld a,(hl)
ldi
or (hl)
ldi
jp nz, remove
scf
ret
|
//----------------------------------------------------------------------------
//
// License: See top level LICENSE.txt file.
//
// Author: David Burken
//
// Description: Test code for generic ossim test.
//
// $Id: ossim-test.cpp 19751 2011-06-13 15:13:07Z dburken $
//----------------------------------------------------------------------------
#include <iostream>
#include <iomanip>
using namespace std;
#include <ossim/base/ossimConstants.h>
#include <ossim/base/ossimCommon.h>
#include <ossim/base/ossimEnvironmentUtility.h>
#include <ossim/init/ossimInit.h>
int main(int argc, char *argv[])
{
ossimInit::instance()->initialize(argc, argv);
cout << "running ossim::isnan test..." << endl;
double d = ossim::nan();
if (ossim::isnan(d))
{
cout << "ossim::isnan test passed..." << endl;
}
else
{
cout << "ossim::isnan test failed..." << endl;
}
cout << "running ossimEnvironmentUtility test..."
<< "\ngetUserDir(): "
<< ossimEnvironmentUtility::instance()->getUserDir()
<< "\ngetUserName(): "
<< ossimEnvironmentUtility::instance()->getUserName()
<< "\ngetUserOssimSupportDir(): "
<< ossimEnvironmentUtility::instance()->getUserOssimSupportDir()
<< "\ngetUserOssimPreferences(): "
<< ossimEnvironmentUtility::instance()->getUserOssimPreferences()
<< "\ngetUserOssimPluginDir()"
<< ossimEnvironmentUtility::instance()->getUserOssimPluginDir()
<< "\ngetInstalledOssimSupportDir(): "
<< ossimEnvironmentUtility::instance()->getInstalledOssimSupportDir()
<< "\ngetInstalledOssimPluginDir(): "
<< ossimEnvironmentUtility::instance()->getInstalledOssimPluginDir()
<< "\ngetInstalledOssimPreferences(): "
<< ossimEnvironmentUtility::instance()->getInstalledOssimPreferences()
<< "\ngetCurrentWorkingDir(): "
<< ossimEnvironmentUtility::instance()->getCurrentWorkingDir()
<< endl;
cout << "ossim::round<> test:";
ossim_float64 f1 = 8.193933404085605;
cout << std::setiosflags(ios::fixed) << std::setprecision(15) << "\nf1: " << f1;
f1 = ossim::round<int>(f1 / 0.000005359188182);
cout << std::setiosflags(ios::fixed) << std::setprecision(15) << "\nossim::round<int>(d / 0.000005359188182): " << f1;
return 0;
}
|
WORDS ; The following addresses are 16 bits long
segment byte at 4000-407F 'EEPROM'
WORDS ; The following addresses are 16 bits long
segment byte at 8080-9FFF 'ROM'
WORDS ; The following addresses are 16 bits long
segment byte at 8000-807F 'INTERRUPT'
;=======Register==============================
PORTA EQU $5000
PINA EQU $5001
DDRA EQU $5002
CR1A EQU $5003
CR2A EQU $5004
PORTB EQU $5005
PINB EQU $5006
DDRB EQU $5007
CR1B EQU $5008
CR2B EQU $5009
PORTC EQU $500A
PINC EQU $500B
DDRC EQU $500C
CR1C EQU $500D
CR2C EQU $500E
PORTD EQU $500F
PIND EQU $5010
DDRD EQU $5011
CR1D EQU $5012
CR2D EQU $5013
;==========================
EXTI_CR1 EQU $50A0 ; External interrupt control register 1 0x00
EXTI_CR2 EQU $50A1 ; External interrupt control register 2 0x00
RST_SR EQU $50B3 ; Reset status register 0xXX
;==========================
CLK_ICKR EQU $50C0 ; Internal clock control register 0x01
CLK_ECKR EQU $50C1 ; External clock control register 0x00
CLK_CMSR EQU $50C3 ; Clock master status register 0xE1
CLK_SWR EQU $50C4 ; Clock master switch register 0xE1
CLK_SWCR EQU $50C5 ; Clock switch control register 0xXX
CLK_CKDIVR EQU $50C6 ; Clock divider register 0x18
CLK_PCKENR1 EQU $50C7 ; Peripheral clock gating register 1 0xFF
CLK_CSSR EQU $50C8 ; Clock security system register 0x00
CLK_CCOR EQU $50C9 ; Configurable clock control register 0x00
CLK_PCKENR2 EQU $50CA ; Peripheral clock gating register 2 0xFF
CLK_CANCCR EQU $50CB ; CAN clock control register 0x00
CLK_HSITRIMR EQU $50CC ; HSI clock calibration trimming register 0x00
CLK_SWIMCCR EQU $50CD ; SWIM clock control register 0bXXXX XXX0
;==========================
UART1_SR EQU $5230 ; UART1 status register 0xC0
UART1_DR EQU $5231 ; UART1 data register 0xXX
UART1_BRR1 EQU $5232 ; UART1 baud rate register 0x00
UART1_BRR2 EQU $5233 ; UART1 baud rate register 0x00
UART1_CR1 EQU $5234 ; UART1 control register 1 0x00
UART1_CR2 EQU $5235 ; UART1 control register 2 0x00
UART1_CR3 EQU $5236 ; UART1 control register 3 0x00
UART1_CR4 EQU $5237 ; UART1 control register 4 0x00
UART1_CR5 EQU $5238 ; UART1 control register 5 0x00
UART1_GTR EQU $5239 ; UART1 guard time register 0x00
UART1_PSCR EQU $523A ; UART1 prescaler register 0x00
SBK EQU 0 ; Send break
RWU EQU 1 ; Receiver wakeup
REN EQU 2 ; Receiver enable
TEN EQU 3 ; Transmitter enable
ILIEN EQU 4 ; IDLE Line interrupt enable
RIEN EQU 5 ; Receiver interrupt enable
TCIEN EQU 6 ; Transmission complete interrupt enable
TIEN EQU 7 ; Transmitter interrupt enable
TC EQU 6 ; Transmission complete
;==========================
SPI_CR1 EQU $5200 ; SPI control register 1 0x00
SPI_CR2 EQU $5201 ; SPI control register 2 0x00
SPI_ICR EQU $5202 ; SPI interrupt control register 0x00
SPI_SR EQU $5203 ; SPI status register 0x02
SPI_DR EQU $5204 ; SPI data register 0x00
SPI_CRCPR EQU $5205 ; SPI CRC polynomial register 0x07
SPI_RXCRCR EQU $5206 ; SPI Rx CRC register 0xFF
SPI_TXCRCR EQU $5207 ; SPI Tx CRC register 0xFF
;==========================
FLASH_CR1 EQU $505A ; Flash control register 1 0x00
FLASH_CR2 EQU $505B ; Flash control register 2 0x00
FLASH_NCR2 EQU $505C ; Flash complementary control register 2 0xFF
FLASH_FPR EQU $505D ; Flash protection register 0x00
FLASH_NFPR EQU $505E ; Flash complementary protection register 0xFF
FLASH_IAPSR EQU $505F ; Flash in-application programming status register 0x00
FLASH_PUKR EQU $5062 ; Flash program memory unprotection register 0x00
FLASH_DUKR EQU $5064 ; Data EEPROM unprotection register 0x00
;==========================
WWDG_CR EQU $50D1 ; WWDG control register 0x7F
WWDG_WR EQU $50D2 ; WWDR window register 0x7F
IWDG_KR EQU $50E0 ; IWDG key register 0xXX
IWDG_PR EQU $50E1 ; IWDG prescaler register 0x00
IWDG_RLR EQU $50E2 ; IWDG reload register 0xFF
AWU_CSR1 EQU $50F0 ; AWU control/status register 1 0x00
AWU_APR EQU $50F1 ; AWU asynchronous prescaler buffer register 0x3F
AWU_TBR EQU $50F2 ; AWU timebase selection register 0x00
BEEP_CSR EQU $50F3 ; BEEP control/status register 0x1F
;==========================
TIM1_CR1 EQU $5250 ; TIM1 control register 1 0x00
TIM1_CR2 EQU $5251 ; TIM1 control register 2 0x00
TIM1_SMCR EQU $5252 ; TIM1 slave mode control register 0x00
TIM1_ETR EQU $5253 ; TIM1 external trigger register 0x00
TIM1_IER EQU $5254 ; TIM1 interrupt enable register 0x00
TIM1_SR1 EQU $5255 ; TIM1 status register 1 0x00
TIM1_SR2 EQU $5256 ; TIM1 status register 2 0x00
TIM1_EGR EQU $5257 ; TIM1 event generation register 0x00
TIM1_CCMR1 EQU $5258 ; TIM1 capture/compare mode register 1 0x00
TIM1_CCMR2 EQU $5259 ; TIM1 capture/compare mode register 2 0x00
TIM1_CCMR3 EQU $525A ; TIM1 capture/compare mode register 3 0x00
TIM1_CCMR4 EQU $525B ; TIM1 capture/compare mode register 4 0x00
TIM1_CCER1 EQU $525C ; TIM1 capture/compare enable register 1 0x00
TIM1_CCER2 EQU $525D ; TIM1 capture/compare enable register 2 0x00
TIM1_CNTRH EQU $525E ; TIM1 counter high 0x00
TIM1_CNTRL EQU $525F ; TIM1 counter low 0x00
TIM1_PSCRH EQU $5260 ; TIM1 prescaler register high 0x00
TIM1_PSCRL EQU $5261 ; TIM1 prescaler register low 0x00
TIM1_ARRH EQU $5262 ; TIM1 auto-reload register high 0xFF
TIM1_ARRL EQU $5263 ; TIM1 auto-reload register low 0xFF
TIM1_RCR EQU $5264 ; TIM1 repetition counter register 0x00
TIM1_CCR1H EQU $5265 ; TIM1 capture/compare register 1 high 0x00
TIM1_CCR1L EQU $5266 ; TIM1 capture/compare register 1 low 0x00
TIM1_CCR2H EQU $5267 ; TIM1 capture/compare register 2 high 0x00
TIM1_CCR2L EQU $5268 ; TIM1 capture/compare register 2 low 0x00
TIM1_CCR3H EQU $5269 ; TIM1 capture/compare register 3 high 0x00
TIM1_CCR3L EQU $526A ; TIM1 capture/compare register 3 low 0x00
TIM1_CCR4H EQU $526B ; TIM1 capture/compare register 4 high 0x00
TIM1_CCR4L EQU $526C ; TIM1 capture/compare register 4 low 0x00
TIM1_BKR EQU $526D ; TIM1 break register 0x00
TIM1_DTR EQU $526E ; TIM1 dead-time register 0x00
TIM1_OISR EQU $526F ; TIM1 output idle state register 0x00
;==========================
TIM2_CR1 EQU $5300 ; TIM2 control register 1 0x00
TIM2_IER EQU $5303 ; TIM2 Interrupt enable register 0x00
TIM2_SR1 EQU $5304 ; TIM2 status register 1 0x00
TIM2_SR2 EQU $5305 ; TIM2 status register 2 0x00
TIM2_EGR EQU $5306 ; TIM2 event generation register 0x00
TIM2_CCMR1 EQU $5307 ; TIM2 capture/compare mode register 1 0x00
TIM2_CCMR2 EQU $5308 ; TIM2 capture/compare mode register 2 0x00
TIM2_CCMR3 EQU $5309 ; TIM2 capture/compare mode register 3 0x00
TIM2_CCER1 EQU $530A ; TIM2 capture/compare enable register 1 0x00
TIM2_CCER2 EQU $530B ; TIM2 capture/compare enable register 2 0x00
TIM2_CNTRH EQU $530C ; TIM2 counter high 0x00
TIM2_CNTRL EQU $530D ; TIM2 prescaler register
TIM2_PSCR EQU $530E ; TIM2 prescaler register
TIM2_ARRH EQU $530F ; TIM2 auto-reload register high 0xFF
TIM2_ARRL EQU $5310 ; TIM2 auto-reload register low 0xFF
TIM2_CCR1H EQU $5312 ; TIM2 capture/compare register 1 high 0x00
TIM2_CCR1L EQU $5312 ; TIM2 capture/compare register 1 low 0x00
TIM2_CCR2H EQU $5313 ; TIM2 capture/compare reg. 2 high 0x00
TIM2_CCR2L EQU $5314 ; TIM2 capture/compare register 2 low 0x00
TIM2_CCR3H EQU $5315 ; TIM2 capture/compare register 3 high 0x00
TIM2_CCR3L EQU $5316 ; TIM2 capture/compare register 3 low 0x00
;==========================
TIM4_CR1 EQU $5340 ; TIM4 control register 1 0x00
TIM4_IER EQU $5343 ; TIM4 interrupt enable register 0x00
TIM4_SR EQU $5344 ; TIM4 status register 0x00
TIM4_EGR EQU $5345 ; TIM4 event generation register 0x00
TIM4_CNTR EQU $5346 ; TIM4 counter 0x00
TIM4_PSCR EQU $5347 ; TIM4 prescaler register 0x00
TIM4_ARR EQU $5348 ; TIM4 auto-reload register 0xFF
CEN EQU 0 ; Counter enable
UDIS EQU 1 ; Update disable
URS EQU 2 ; Update request source
OPM EQU 3 ; One pulse mode
ARPE EQU 7 ; Auto-reload preload enable
UIE EQU 0 ; Update interrupt enable
TIE EQU 6 ; Trigger interrupt enable
UIF EQU 0 ; Update interrupt flag
TIF EQU 6 ; Trigger interrupt flag TIM4 this bit is reserved
UG EQU 0 ; Update generation
TG EQU 6 ; Trigger generation
;==========================
;ADC_DBxR $53E0-$53F3 ; ADC data buffer registers 0x00
ADC_CSR EQU $5400 ; ADC control/status register 0x00
ADC_CR1 EQU $5401 ; ADC configuration register 1 0x00
ADC_CR2 EQU $5402 ; ADC configuration register 2 0x00
ADC_CR3 EQU $5403 ; ADC configuration register 3 0x00
ADC_DRH EQU $5404 ; ADC data register high 0xXX
ADC_DRL EQU $5405 ; ADC data register low 0xXX
ADC_TDRH EQU $5406 ; ADC Schmitt trigger disable register high 0x00
ADC_TDRL EQU $5407 ; ADC Schmitt trigger disable register low 0x00
ADC_HTRH EQU $5408 ; ADC high threshold register high 0x03
ADC_HTRL EQU $5409 ; ADC high threshold register low 0xFF
ADC_LTRH EQU $540A ; ADC low threshold register high 0x00
ADC_LTRL EQU $540B ; ADC low threshold register low 0x00
ADC_AWSRH EQU $540C ; ADC analog watchdog status register high 0x00
ADC_AWSRL EQU $540D ; ADC analog watchdog status register low 0x00
ADC_AWCRH EQU $540E ; ADC analog watchdog control register high 0x00
ADC_AWCRL EQU $540F ; ADC analog watchdog control register low 0x00
;==========================
CFG_GCR EQU $7F60 ; Global configuration register 0x00
ITC_SPR1 EQU $7F70 ; Interrupt software priority register 1 0xFF
ITC_SPR2 EQU $7F71 ; Interrupt software priority register 2 0xFF
ITC_SPR3 EQU $7F72 ; Interrupt software priority register 3 0xFF
ITC_SPR4 EQU $7F73 ; Interrupt software priority register 4 0xFF
ITC_SPR5 EQU $7F74 ; Interrupt software priority register 5 0xFF
ITC_SPR6 EQU $7F75 ; Interrupt software priority register 6 0xFF
ITC_SPR7 EQU $7F76 ; Interrupt software priority register 7 0xFF
ITC_SPR8 EQU $7F77 ; Interrupt software priority register 8 0xFF
SWIM_CSR EQU $7F80 ; SWIM control status register 0x00
;==========================
CCR EQU $7F0A ;
X_L EQU $7F05
X_H EQU $7F04
Y_L EQU $7F07
Y_H EQU $7F06
ACC EQU $7F00
;=======end==========================================================
SEGMENT 'ROM'
NoneInterrupt:
IRET
InitMemory:
;Clear memory
LDW X,#$0200
LDW SP,X
LDW X,#$0000
ClearRam0:
CLR (X)
INCW X
CPW X,#$03FF
JRULE ClearRam0
call SystemStart
GeneralCycle:
WFI
JP GeneralCycle
END
|
module random
{
var randint(var start,var end){
return math.random(start,end);
}
var randrange(var start,var end){
return math.random(start,end-1);
}
var choice(var v){
if(isstring(v)){
var p = randrange(0,len(v));
return string.at(v,p);
}
else if(isvector(v)){
var p = randrange(0,len(v));
return v[p];
}
}
var simple(var v,var count = 1){
if(!isstring(v) && !isvector(v)) return null;
var hased = [];
var ret = [];
while(hased.size() < len(v) && hased.size() < count){
if(isstring(v)){
var p = randrange(0,len(v));
if(hased.has(p)) continue;
hased.push_back(p);
ret.push_back(string.at(v,p));
}
else if(isvector(v)){
var p = randrange(0,len(v));
if(hased.has(p)) continue;
hased.push_back(p);
ret.push_back(v[p]);
}
}
return ret;
}
} |
/* (c) Magnus Auvinen. See licence.txt in the root of the distribution for more information. */
/* If you are missing that file, acquire a complete release at teeworlds.com. */
#include <new>
#include <base/math.h>
#include <engine/shared/config.h>
#include <engine/map.h>
#include <engine/console.h>
#include "gamecontext.h"
#include <game/version.h>
#include <game/collision.h>
#include <game/gamecore.h>
#include "gamemodes/survdm.h"
#include "gamemodes/survtdm.h"
#include "gamemodes/dm.h"
#include "gamemodes/tdm.h"
#include "gamemodes/ctf.h"
#include "gamemodes/mod.h"
enum
{
RESET,
NO_RESET
};
void CGameContext::Construct(int Resetting)
{
m_Resetting = 0;
m_pServer = 0;
for(int i = 0; i < MAX_CLIENTS; i++)
m_apPlayers[i] = 0;
m_pController = 0;
m_VoteCloseTime = 0;
m_pVoteOptionFirst = 0;
m_pVoteOptionLast = 0;
m_NumVoteOptions = 0;
m_LockTeams = 0;
if(Resetting==NO_RESET)
m_pVoteOptionHeap = new CHeap();
}
CGameContext::CGameContext(int Resetting)
{
Construct(Resetting);
}
CGameContext::CGameContext()
{
Construct(NO_RESET);
}
CGameContext::~CGameContext()
{
for(int i = 0; i < MAX_CLIENTS; i++)
delete m_apPlayers[i];
if(!m_Resetting)
delete m_pVoteOptionHeap;
}
void CGameContext::Clear()
{
CHeap *pVoteOptionHeap = m_pVoteOptionHeap;
CVoteOptionServer *pVoteOptionFirst = m_pVoteOptionFirst;
CVoteOptionServer *pVoteOptionLast = m_pVoteOptionLast;
int NumVoteOptions = m_NumVoteOptions;
CTuningParams Tuning = m_Tuning;
m_Resetting = true;
this->~CGameContext();
mem_zero(this, sizeof(*this));
new (this) CGameContext(RESET);
m_pVoteOptionHeap = pVoteOptionHeap;
m_pVoteOptionFirst = pVoteOptionFirst;
m_pVoteOptionLast = pVoteOptionLast;
m_NumVoteOptions = NumVoteOptions;
m_Tuning = Tuning;
}
class CCharacter *CGameContext::GetPlayerChar(int ClientID)
{
if(ClientID < 0 || ClientID >= MAX_CLIENTS || !m_apPlayers[ClientID])
return 0;
return m_apPlayers[ClientID]->GetCharacter();
}
void CGameContext::CreateDamageInd(vec2 Pos, float Angle, int Amount)
{
float a = 3 * 3.14159f / 2 + Angle;
//float a = get_angle(dir);
float s = a-pi/3;
float e = a+pi/3;
for(int i = 0; i < Amount; i++)
{
float f = mix(s, e, float(i+1)/float(Amount+2));
CNetEvent_DamageInd *pEvent = (CNetEvent_DamageInd *)m_Events.Create(NETEVENTTYPE_DAMAGEIND, sizeof(CNetEvent_DamageInd));
if(pEvent)
{
pEvent->m_X = (int)Pos.x;
pEvent->m_Y = (int)Pos.y;
pEvent->m_Angle = (int)(f*256.0f);
}
}
}
void CGameContext::CreateHammerHit(vec2 Pos)
{
// create the event
CNetEvent_HammerHit *pEvent = (CNetEvent_HammerHit *)m_Events.Create(NETEVENTTYPE_HAMMERHIT, sizeof(CNetEvent_HammerHit));
if(pEvent)
{
pEvent->m_X = (int)Pos.x;
pEvent->m_Y = (int)Pos.y;
}
}
void CGameContext::CreateExplosion(vec2 Pos, int Owner, int Weapon, bool NoDamage)
{
// create the event
CNetEvent_Explosion *pEvent = (CNetEvent_Explosion *)m_Events.Create(NETEVENTTYPE_EXPLOSION, sizeof(CNetEvent_Explosion));
if(pEvent)
{
pEvent->m_X = (int)Pos.x;
pEvent->m_Y = (int)Pos.y;
}
if (!NoDamage)
{
// deal damage
CCharacter *apEnts[MAX_CLIENTS];
float Radius = 135.0f;
float InnerRadius = 48.0f;
int Num = m_World.FindEntities(Pos, Radius, (CEntity**)apEnts, MAX_CLIENTS, CGameWorld::ENTTYPE_CHARACTER);
for(int i = 0; i < Num; i++)
{
vec2 Diff = apEnts[i]->m_Pos - Pos;
vec2 ForceDir(0,1);
float l = length(Diff);
if(l)
ForceDir = normalize(Diff);
l = 1-clamp((l-InnerRadius)/(Radius-InnerRadius), 0.0f, 1.0f);
float Dmg = 6 * l;
if((int)Dmg)
apEnts[i]->TakeDamage(ForceDir*Dmg*2, (int)Dmg, Owner, Weapon);
}
}
}
/*
void create_smoke(vec2 Pos)
{
// create the event
EV_EXPLOSION *pEvent = (EV_EXPLOSION *)events.create(EVENT_SMOKE, sizeof(EV_EXPLOSION));
if(pEvent)
{
pEvent->x = (int)Pos.x;
pEvent->y = (int)Pos.y;
}
}*/
void CGameContext::CreatePlayerSpawn(vec2 Pos)
{
// create the event
CNetEvent_Spawn *ev = (CNetEvent_Spawn *)m_Events.Create(NETEVENTTYPE_SPAWN, sizeof(CNetEvent_Spawn));
if(ev)
{
ev->m_X = (int)Pos.x;
ev->m_Y = (int)Pos.y;
}
}
void CGameContext::CreateDeath(vec2 Pos, int ClientID)
{
// create the event
CNetEvent_Death *pEvent = (CNetEvent_Death *)m_Events.Create(NETEVENTTYPE_DEATH, sizeof(CNetEvent_Death));
if(pEvent)
{
pEvent->m_X = (int)Pos.x;
pEvent->m_Y = (int)Pos.y;
pEvent->m_ClientID = ClientID;
}
}
void CGameContext::CreateSound(vec2 Pos, int Sound, int Mask)
{
if (Sound < 0)
return;
// create a sound
CNetEvent_SoundWorld *pEvent = (CNetEvent_SoundWorld *)m_Events.Create(NETEVENTTYPE_SOUNDWORLD, sizeof(CNetEvent_SoundWorld), Mask);
if(pEvent)
{
pEvent->m_X = (int)Pos.x;
pEvent->m_Y = (int)Pos.y;
pEvent->m_SoundID = Sound;
}
}
void CGameContext::CreateSoundGlobal(int Sound, int Target)
{
if (Sound < 0)
return;
CNetMsg_Sv_SoundGlobal Msg;
Msg.m_SoundID = Sound;
if(Target == -2)
Server()->SendPackMsg(&Msg, MSGFLAG_NOSEND, -1);
else
{
int Flag = MSGFLAG_VITAL;
if(Target != -1)
Flag |= MSGFLAG_NORECORD;
Server()->SendPackMsg(&Msg, Flag, Target);
}
}
void CGameContext::SendChatTarget(int To, const char *pText)
{
CNetMsg_Sv_Chat Msg;
Msg.m_Team = 0;
Msg.m_ClientID = -1;
Msg.m_pMessage = pText;
Server()->SendPackMsg(&Msg, MSGFLAG_VITAL, To);
}
void CGameContext::SendChat(int ChatterClientID, int Team, const char *pText)
{
char aBuf[256];
if(ChatterClientID >= 0 && ChatterClientID < MAX_CLIENTS)
str_format(aBuf, sizeof(aBuf), "%d:%d:%s: %s", ChatterClientID, Team, Server()->ClientName(ChatterClientID), pText);
else
str_format(aBuf, sizeof(aBuf), "*** %s", pText);
Console()->Print(IConsole::OUTPUT_LEVEL_ADDINFO, Team!=CHAT_ALL?"teamchat":"chat", aBuf);
if(Team == CHAT_ALL)
{
CNetMsg_Sv_Chat Msg;
Msg.m_Team = 0;
Msg.m_ClientID = ChatterClientID;
Msg.m_pMessage = pText;
Server()->SendPackMsg(&Msg, MSGFLAG_VITAL, -1);
}
else
{
CNetMsg_Sv_Chat Msg;
Msg.m_Team = 1;
Msg.m_ClientID = ChatterClientID;
Msg.m_pMessage = pText;
// pack one for the recording only
Server()->SendPackMsg(&Msg, MSGFLAG_VITAL|MSGFLAG_NOSEND, -1);
// send to the clients
for(int i = 0; i < MAX_CLIENTS; i++)
{
if(m_apPlayers[i] && m_apPlayers[i]->GetTeam() == Team)
Server()->SendPackMsg(&Msg, MSGFLAG_VITAL|MSGFLAG_NORECORD, i);
}
}
}
void CGameContext::SendEmoticon(int ClientID, int Emoticon)
{
CNetMsg_Sv_Emoticon Msg;
Msg.m_ClientID = ClientID;
Msg.m_Emoticon = Emoticon;
Server()->SendPackMsg(&Msg, MSGFLAG_VITAL, -1);
}
void CGameContext::SendWeaponPickup(int ClientID, int Weapon)
{
CNetMsg_Sv_WeaponPickup Msg;
Msg.m_Weapon = Weapon;
Server()->SendPackMsg(&Msg, MSGFLAG_VITAL, ClientID);
}
void CGameContext::SendBroadcast(const char *pText, int ClientID)
{
CNetMsg_Sv_Broadcast Msg;
Msg.m_pMessage = pText;
Server()->SendPackMsg(&Msg, MSGFLAG_VITAL, ClientID);
}
void CGameContext::StartVote(const char *pDesc, const char *pCommand, const char *pReason)
{
// check if a vote is already running
if(m_VoteCloseTime)
return;
// reset votes
m_VoteEnforce = VOTE_ENFORCE_UNKNOWN;
for(int i = 0; i < MAX_CLIENTS; i++)
{
if(m_apPlayers[i])
{
m_apPlayers[i]->m_Vote = 0;
m_apPlayers[i]->m_VotePos = 0;
}
}
// start vote
m_VoteCloseTime = time_get() + time_freq()*25;
str_copy(m_aVoteDescription, pDesc, sizeof(m_aVoteDescription));
str_copy(m_aVoteCommand, pCommand, sizeof(m_aVoteCommand));
str_copy(m_aVoteReason, pReason, sizeof(m_aVoteReason));
SendVoteSet(-1);
m_VoteUpdate = true;
}
void CGameContext::EndVote()
{
m_VoteCloseTime = 0;
SendVoteSet(-1);
}
void CGameContext::SendVoteSet(int ClientID)
{
CNetMsg_Sv_VoteSet Msg;
if(m_VoteCloseTime)
{
Msg.m_Timeout = (m_VoteCloseTime-time_get())/time_freq();
Msg.m_pDescription = m_aVoteDescription;
Msg.m_pReason = m_aVoteReason;
}
else
{
Msg.m_Timeout = 0;
Msg.m_pDescription = "";
Msg.m_pReason = "";
}
Server()->SendPackMsg(&Msg, MSGFLAG_VITAL, ClientID);
}
void CGameContext::SendVoteStatus(int ClientID, int Total, int Yes, int No)
{
CNetMsg_Sv_VoteStatus Msg = {0};
Msg.m_Total = Total;
Msg.m_Yes = Yes;
Msg.m_No = No;
Msg.m_Pass = Total - (Yes+No);
Server()->SendPackMsg(&Msg, MSGFLAG_VITAL, ClientID);
}
void CGameContext::AbortVoteKickOnDisconnect(int ClientID)
{
if(m_VoteCloseTime && ((!str_comp_num(m_aVoteCommand, "kick ", 5) && str_toint(&m_aVoteCommand[5]) == ClientID) ||
(!str_comp_num(m_aVoteCommand, "set_team ", 9) && str_toint(&m_aVoteCommand[9]) == ClientID)))
m_VoteCloseTime = -1;
}
void CGameContext::CheckPureTuning()
{
// might not be created yet during start up
if(!m_pController)
return;
if( str_comp(m_pController->m_pGameType, "DM")==0 ||
str_comp(m_pController->m_pGameType, "TDM")==0 ||
str_comp(m_pController->m_pGameType, "CTF")==0)
{
CTuningParams p;
if(mem_comp(&p, &m_Tuning, sizeof(p)) != 0)
{
Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "server", "resetting tuning due to pure server");
m_Tuning = p;
}
}
}
void CGameContext::SendTuningParams(int ClientID)
{
CheckPureTuning();
CMsgPacker Msg(NETMSGTYPE_SV_TUNEPARAMS);
int *pParams = (int *)&m_Tuning;
for(unsigned i = 0; i < sizeof(m_Tuning)/sizeof(int); i++)
Msg.AddInt(pParams[i]);
Server()->SendMsg(&Msg, MSGFLAG_VITAL, ClientID);
}
void CGameContext::SwapTeams()
{
if(!m_pController->IsTeamplay())
return;
SendChat(-1, CGameContext::CHAT_ALL, "Teams were swapped");
for(int i = 0; i < MAX_CLIENTS; ++i)
{
if(m_apPlayers[i] && m_apPlayers[i]->GetTeam() != TEAM_SPECTATORS)
m_apPlayers[i]->SetTeam(m_apPlayers[i]->GetTeam()^1, false);
}
(void)m_pController->CheckTeamBalance();
}
void CGameContext::OnTick()
{
// check tuning
CheckPureTuning();
// copy tuning
m_World.m_Core.m_Tuning = m_Tuning;
m_World.Tick();
//if(world.paused) // make sure that the game object always updates
m_pController->Tick();
for(int i = 0; i < MAX_CLIENTS; i++)
{
if(m_apPlayers[i])
{
m_apPlayers[i]->Tick();
m_apPlayers[i]->PostTick();
}
}
// update voting
if(m_VoteCloseTime)
{
// abort the kick-vote on player-leave
if(m_VoteCloseTime == -1)
{
SendChat(-1, CGameContext::CHAT_ALL, "Vote aborted");
EndVote();
}
else
{
int Total = 0, Yes = 0, No = 0;
if(m_VoteUpdate)
{
// count votes
char aaBuf[MAX_CLIENTS][NETADDR_MAXSTRSIZE] = {{0}};
for(int i = 0; i < MAX_CLIENTS; i++)
if(m_apPlayers[i])
Server()->GetClientAddr(i, aaBuf[i], NETADDR_MAXSTRSIZE);
bool aVoteChecked[MAX_CLIENTS] = {0};
for(int i = 0; i < MAX_CLIENTS; i++)
{
if(!m_apPlayers[i] || aVoteChecked[i]) // don't count in votes by spectators
continue;
int ActVote = m_apPlayers[i]->m_Vote;
int ActVotePos = m_apPlayers[i]->m_VotePos;
// check for more players with the same ip (only use the vote of the one who voted first)
for(int j = i+1; j < MAX_CLIENTS; ++j)
{
if(!m_apPlayers[j] || aVoteChecked[j] || str_comp(aaBuf[j], aaBuf[i]))
continue;
aVoteChecked[j] = true;
if(m_apPlayers[j]->m_Vote && (!ActVote || ActVotePos > m_apPlayers[j]->m_VotePos))
{
ActVote = m_apPlayers[j]->m_Vote;
ActVotePos = m_apPlayers[j]->m_VotePos;
}
}
Total++;
if(ActVote > 0)
Yes++;
else if(ActVote < 0)
No++;
}
if(Yes >= Total/2+1)
m_VoteEnforce = VOTE_ENFORCE_YES;
else if(No >= (Total+1)/2)
m_VoteEnforce = VOTE_ENFORCE_NO;
}
if(m_VoteEnforce == VOTE_ENFORCE_YES)
{
Server()->SetRconCID(IServer::RCON_CID_VOTE);
Console()->ExecuteLine(m_aVoteCommand);
Server()->SetRconCID(IServer::RCON_CID_SERV);
EndVote();
SendChat(-1, CGameContext::CHAT_ALL, "Vote passed");
if(m_apPlayers[m_VoteCreator])
m_apPlayers[m_VoteCreator]->m_LastVoteCall = 0;
}
else if(m_VoteEnforce == VOTE_ENFORCE_NO || time_get() > m_VoteCloseTime)
{
EndVote();
SendChat(-1, CGameContext::CHAT_ALL, "Vote failed");
}
else if(m_VoteUpdate)
{
m_VoteUpdate = false;
SendVoteStatus(-1, Total, Yes, No);
}
}
}
#ifdef CONF_DEBUG
if(g_Config.m_DbgDummies)
{
for(int i = 0; i < g_Config.m_DbgDummies ; i++)
{
CNetObj_PlayerInput Input = {0};
Input.m_Direction = (i&1)?-1:1;
m_apPlayers[MAX_CLIENTS-i-1]->OnPredictedInput(&Input);
}
}
#endif
}
// Server hooks
void CGameContext::OnClientDirectInput(int ClientID, void *pInput)
{
if(!m_World.m_Paused)
m_apPlayers[ClientID]->OnDirectInput((CNetObj_PlayerInput *)pInput);
}
void CGameContext::OnClientPredictedInput(int ClientID, void *pInput)
{
if(!m_World.m_Paused)
m_apPlayers[ClientID]->OnPredictedInput((CNetObj_PlayerInput *)pInput);
}
void CGameContext::OnClientEnter(int ClientID)
{
//world.insert_entity(&players[client_id]);
//m_apPlayers[ClientID]->Respawn();
char aBuf[512];
str_format(aBuf, sizeof(aBuf), "'%s' entered and joined the %s", Server()->ClientName(ClientID), m_pController->GetTeamName(m_apPlayers[ClientID]->GetTeam()));
SendChat(-1, CGameContext::CHAT_ALL, aBuf);
SendChatTarget(ClientID, "Welcome to Surv Mod 0.3!");
SendChatTarget(ClientID, "Server coded by Psycho.God!");
SendChatTarget(ClientID, "Good luck! Have fun!");
str_format(aBuf, sizeof(aBuf), "team_join player='%d:%s' team=%d", ClientID, Server()->ClientName(ClientID), m_apPlayers[ClientID]->GetTeam());
Console()->Print(IConsole::OUTPUT_LEVEL_DEBUG, "game", aBuf);
m_VoteUpdate = true;
}
void CGameContext::OnClientConnected(int ClientID)
{
// Check which team the player should be on
const int StartTeam = TEAM_SPECTATORS;
m_apPlayers[ClientID] = new(ClientID) CPlayer(this, ClientID, StartTeam);
//players[client_id].init(client_id);
//players[client_id].client_id = client_id;
(void)m_pController->CheckTeamBalance();
#ifdef CONF_DEBUG
if(g_Config.m_DbgDummies)
{
if(ClientID >= MAX_CLIENTS-g_Config.m_DbgDummies)
return;
}
#endif
// send active vote
if(m_VoteCloseTime)
SendVoteSet(ClientID);
// send motd
CNetMsg_Sv_Motd Msg;
Msg.m_pMessage = g_Config.m_SvMotd;
Server()->SendPackMsg(&Msg, MSGFLAG_VITAL, ClientID);
}
void CGameContext::OnClientDrop(int ClientID, const char *pReason)
{
AbortVoteKickOnDisconnect(ClientID);
m_apPlayers[ClientID]->OnDisconnect(pReason);
delete m_apPlayers[ClientID];
m_apPlayers[ClientID] = 0;
(void)m_pController->CheckTeamBalance();
m_VoteUpdate = true;
// update spectator modes
for(int i = 0; i < MAX_CLIENTS; ++i)
{
if(m_apPlayers[i] && m_apPlayers[i]->m_SpectatorID == ClientID)
m_apPlayers[i]->m_SpectatorID = SPEC_FREEVIEW;
}
}
void CGameContext::OnMessage(int MsgID, CUnpacker *pUnpacker, int ClientID)
{
void *pRawMsg = m_NetObjHandler.SecureUnpackMsg(MsgID, pUnpacker);
CPlayer *pPlayer = m_apPlayers[ClientID];
if(!pRawMsg)
{
char aBuf[256];
str_format(aBuf, sizeof(aBuf), "dropped weird message '%s' (%d), failed on '%s'", m_NetObjHandler.GetMsgName(MsgID), MsgID, m_NetObjHandler.FailedMsgOn());
Console()->Print(IConsole::OUTPUT_LEVEL_DEBUG, "server", aBuf);
return;
}
if(MsgID == NETMSGTYPE_CL_SAY)
{
CNetMsg_Cl_Say *pMsg = (CNetMsg_Cl_Say *)pRawMsg;
int Team = pMsg->m_Team;
if(Team)
Team = pPlayer->GetTeam();
else
Team = CGameContext::CHAT_ALL;
if(g_Config.m_SvSpamprotection && pPlayer->m_LastChat && pPlayer->m_LastChat+Server()->TickSpeed() > Server()->Tick())
return;
pPlayer->m_LastChat = Server()->Tick();
// check for invalid chars
unsigned char *pMessage = (unsigned char *)pMsg->m_pMessage;
while (*pMessage)
{
if(*pMessage < 32)
*pMessage = ' ';
pMessage++;
}
SendChat(ClientID, Team, pMsg->m_pMessage);
}
else if(MsgID == NETMSGTYPE_CL_CALLVOTE)
{
if(g_Config.m_SvSpamprotection && pPlayer->m_LastVoteTry && pPlayer->m_LastVoteTry+Server()->TickSpeed()*3 > Server()->Tick())
return;
int64 Now = Server()->Tick();
pPlayer->m_LastVoteTry = Now;
if(pPlayer->GetTeam() == TEAM_SPECTATORS)
{
SendChatTarget(ClientID, "Spectators aren't allowed to start a vote.");
return;
}
if(m_VoteCloseTime)
{
SendChatTarget(ClientID, "Wait for current vote to end before calling a new one.");
return;
}
int Timeleft = pPlayer->m_LastVoteCall + Server()->TickSpeed()*60 - Now;
if(pPlayer->m_LastVoteCall && Timeleft > 0)
{
char aChatmsg[512] = {0};
str_format(aChatmsg, sizeof(aChatmsg), "You must wait %d seconds before making another vote", (Timeleft/Server()->TickSpeed())+1);
SendChatTarget(ClientID, aChatmsg);
return;
}
char aChatmsg[512] = {0};
char aDesc[VOTE_DESC_LENGTH] = {0};
char aCmd[VOTE_CMD_LENGTH] = {0};
CNetMsg_Cl_CallVote *pMsg = (CNetMsg_Cl_CallVote *)pRawMsg;
const char *pReason = pMsg->m_Reason[0] ? pMsg->m_Reason : "No reason given";
if(str_comp_nocase(pMsg->m_Type, "option") == 0)
{
CVoteOptionServer *pOption = m_pVoteOptionFirst;
while(pOption)
{
if(str_comp_nocase(pMsg->m_Value, pOption->m_aDescription) == 0)
{
str_format(aChatmsg, sizeof(aChatmsg), "'%s' called vote to change server option '%s' (%s)", Server()->ClientName(ClientID),
pOption->m_aDescription, pReason);
str_format(aDesc, sizeof(aDesc), "%s", pOption->m_aDescription);
str_format(aCmd, sizeof(aCmd), "%s", pOption->m_aCommand);
break;
}
pOption = pOption->m_pNext;
}
if(!pOption)
{
str_format(aChatmsg, sizeof(aChatmsg), "'%s' isn't an option on this server", pMsg->m_Value);
SendChatTarget(ClientID, aChatmsg);
return;
}
}
else if(str_comp_nocase(pMsg->m_Type, "kick") == 0)
{
if(!g_Config.m_SvVoteKick)
{
SendChatTarget(ClientID, "Server does not allow voting to kick players");
return;
}
if(g_Config.m_SvVoteKickMin)
{
int PlayerNum = 0;
for(int i = 0; i < MAX_CLIENTS; ++i)
if(m_apPlayers[i] && m_apPlayers[i]->GetTeam() != TEAM_SPECTATORS)
++PlayerNum;
if(PlayerNum < g_Config.m_SvVoteKickMin)
{
str_format(aChatmsg, sizeof(aChatmsg), "Kick voting requires %d players on the server", g_Config.m_SvVoteKickMin);
SendChatTarget(ClientID, aChatmsg);
return;
}
}
int KickID = str_toint(pMsg->m_Value);
if(KickID < 0 || KickID >= MAX_CLIENTS || !m_apPlayers[KickID])
{
SendChatTarget(ClientID, "Invalid client id to kick");
return;
}
if(KickID == ClientID)
{
SendChatTarget(ClientID, "You can't kick yourself");
return;
}
if(Server()->IsAuthed(KickID))
{
SendChatTarget(ClientID, "You can't kick admins");
char aBufKick[128];
str_format(aBufKick, sizeof(aBufKick), "'%s' called for vote to kick you", Server()->ClientName(ClientID));
SendChatTarget(KickID, aBufKick);
return;
}
str_format(aChatmsg, sizeof(aChatmsg), "'%s' called for vote to kick '%s' (%s)", Server()->ClientName(ClientID), Server()->ClientName(KickID), pReason);
str_format(aDesc, sizeof(aDesc), "Kick '%s'", Server()->ClientName(KickID));
if (!g_Config.m_SvVoteKickBantime)
str_format(aCmd, sizeof(aCmd), "kick %d Kicked by vote", KickID);
else
{
char aAddrStr[NETADDR_MAXSTRSIZE] = {0};
Server()->GetClientAddr(KickID, aAddrStr, sizeof(aAddrStr));
str_format(aCmd, sizeof(aCmd), "ban %s %d Banned by vote", aAddrStr, g_Config.m_SvVoteKickBantime);
}
}
else if(str_comp_nocase(pMsg->m_Type, "spectate") == 0)
{
if(!g_Config.m_SvVoteSpectate)
{
SendChatTarget(ClientID, "Server does not allow voting to move players to spectators");
return;
}
int SpectateID = str_toint(pMsg->m_Value);
if(SpectateID < 0 || SpectateID >= MAX_CLIENTS || !m_apPlayers[SpectateID] || m_apPlayers[SpectateID]->GetTeam() == TEAM_SPECTATORS)
{
SendChatTarget(ClientID, "Invalid client id to move");
return;
}
if(SpectateID == ClientID)
{
SendChatTarget(ClientID, "You can't move yourself");
return;
}
str_format(aChatmsg, sizeof(aChatmsg), "'%s' called for vote to move '%s' to spectators (%s)", Server()->ClientName(ClientID), Server()->ClientName(SpectateID), pReason);
str_format(aDesc, sizeof(aDesc), "move '%s' to spectators", Server()->ClientName(SpectateID));
str_format(aCmd, sizeof(aCmd), "set_team %d -1 %d", SpectateID, g_Config.m_SvVoteSpectateRejoindelay);
}
if(aCmd[0])
{
SendChat(-1, CGameContext::CHAT_ALL, aChatmsg);
StartVote(aDesc, aCmd, pReason);
pPlayer->m_Vote = 1;
pPlayer->m_VotePos = m_VotePos = 1;
m_VoteCreator = ClientID;
pPlayer->m_LastVoteCall = Now;
}
}
else if(MsgID == NETMSGTYPE_CL_VOTE)
{
if(!m_VoteCloseTime)
return;
if(pPlayer->m_Vote == 0)
{
CNetMsg_Cl_Vote *pMsg = (CNetMsg_Cl_Vote *)pRawMsg;
if(!pMsg->m_Vote)
return;
pPlayer->m_Vote = pMsg->m_Vote;
pPlayer->m_VotePos = ++m_VotePos;
m_VoteUpdate = true;
}
}
else if (MsgID == NETMSGTYPE_CL_SETTEAM && !m_World.m_Paused)
{
CNetMsg_Cl_SetTeam *pMsg = (CNetMsg_Cl_SetTeam *)pRawMsg;
if(pPlayer->GetTeam() == pMsg->m_Team || (g_Config.m_SvSpamprotection && pPlayer->m_LastSetTeam && pPlayer->m_LastSetTeam+Server()->TickSpeed()*3 > Server()->Tick()))
return;
if(pMsg->m_Team != TEAM_SPECTATORS && m_LockTeams)
{
pPlayer->m_LastSetTeam = Server()->Tick();
SendBroadcast("Teams are locked", ClientID);
return;
}
if(pPlayer->m_TeamChangeTick > Server()->Tick())
{
pPlayer->m_LastSetTeam = Server()->Tick();
int TimeLeft = (pPlayer->m_TeamChangeTick - Server()->Tick())/Server()->TickSpeed();
char aBuf[128];
str_format(aBuf, sizeof(aBuf), "Time to wait before changing team: %02d:%02d", TimeLeft/60, TimeLeft%60);
SendBroadcast(aBuf, ClientID);
return;
}
// Switch team on given client and kill/respawn him
if(m_pController->CanJoinTeam(pMsg->m_Team, ClientID))
{
if(m_pController->CanChangeTeam(pPlayer, pMsg->m_Team))
{
if(pPlayer->m_SpecExplicit == 0)
{
pPlayer->m_LastSetTeam = Server()->Tick();
if(pPlayer->GetTeam() == TEAM_SPECTATORS || pMsg->m_Team == TEAM_SPECTATORS)
m_VoteUpdate = true;
pPlayer->SetTeam(pMsg->m_Team);
(void)m_pController->CheckTeamBalance();
pPlayer->m_TeamChangeTick = Server()->Tick();
}
else
{
SendBroadcast("You can't join while round not ended!", ClientID);
}
}
else
SendBroadcast("Teams must be balanced, please join other team", ClientID);
}
else
{
char aBuf[128];
str_format(aBuf, sizeof(aBuf), "Only %d active players are allowed", Server()->MaxClients()-g_Config.m_SvSpectatorSlots);
SendBroadcast(aBuf, ClientID);
}
}
else if (MsgID == NETMSGTYPE_CL_SETSPECTATORMODE && !m_World.m_Paused)
{
CNetMsg_Cl_SetSpectatorMode *pMsg = (CNetMsg_Cl_SetSpectatorMode *)pRawMsg;
if(pPlayer->GetTeam() != TEAM_SPECTATORS || pPlayer->m_SpectatorID == pMsg->m_SpectatorID || ClientID == pMsg->m_SpectatorID ||
(g_Config.m_SvSpamprotection && pPlayer->m_LastSetSpectatorMode && pPlayer->m_LastSetSpectatorMode+Server()->TickSpeed()*3 > Server()->Tick()))
return;
pPlayer->m_LastSetSpectatorMode = Server()->Tick();
if(pMsg->m_SpectatorID != SPEC_FREEVIEW && (!m_apPlayers[pMsg->m_SpectatorID] || m_apPlayers[pMsg->m_SpectatorID]->GetTeam() == TEAM_SPECTATORS))
SendChatTarget(ClientID, "Invalid spectator id used");
else
pPlayer->m_SpectatorID = pMsg->m_SpectatorID;
}
else if (MsgID == NETMSGTYPE_CL_STARTINFO)
{
if(pPlayer->m_IsReady)
return;
CNetMsg_Cl_StartInfo *pMsg = (CNetMsg_Cl_StartInfo *)pRawMsg;
pPlayer->m_LastChangeInfo = Server()->Tick();
// set start infos
Server()->SetClientName(ClientID, pMsg->m_pName);
Server()->SetClientClan(ClientID, pMsg->m_pClan);
Server()->SetClientCountry(ClientID, pMsg->m_Country);
str_copy(pPlayer->m_TeeInfos.m_SkinName, pMsg->m_pSkin, sizeof(pPlayer->m_TeeInfos.m_SkinName));
pPlayer->m_TeeInfos.m_UseCustomColor = pMsg->m_UseCustomColor;
pPlayer->m_TeeInfos.m_ColorBody = pMsg->m_ColorBody;
pPlayer->m_TeeInfos.m_ColorFeet = pMsg->m_ColorFeet;
m_pController->OnPlayerInfoChange(pPlayer);
// send vote options
CNetMsg_Sv_VoteClearOptions ClearMsg;
Server()->SendPackMsg(&ClearMsg, MSGFLAG_VITAL, ClientID);
CNetMsg_Sv_VoteOptionListAdd OptionMsg;
int NumOptions = 0;
OptionMsg.m_pDescription0 = "";
OptionMsg.m_pDescription1 = "";
OptionMsg.m_pDescription2 = "";
OptionMsg.m_pDescription3 = "";
OptionMsg.m_pDescription4 = "";
OptionMsg.m_pDescription5 = "";
OptionMsg.m_pDescription6 = "";
OptionMsg.m_pDescription7 = "";
OptionMsg.m_pDescription8 = "";
OptionMsg.m_pDescription9 = "";
OptionMsg.m_pDescription10 = "";
OptionMsg.m_pDescription11 = "";
OptionMsg.m_pDescription12 = "";
OptionMsg.m_pDescription13 = "";
OptionMsg.m_pDescription14 = "";
CVoteOptionServer *pCurrent = m_pVoteOptionFirst;
while(pCurrent)
{
switch(NumOptions++)
{
case 0: OptionMsg.m_pDescription0 = pCurrent->m_aDescription; break;
case 1: OptionMsg.m_pDescription1 = pCurrent->m_aDescription; break;
case 2: OptionMsg.m_pDescription2 = pCurrent->m_aDescription; break;
case 3: OptionMsg.m_pDescription3 = pCurrent->m_aDescription; break;
case 4: OptionMsg.m_pDescription4 = pCurrent->m_aDescription; break;
case 5: OptionMsg.m_pDescription5 = pCurrent->m_aDescription; break;
case 6: OptionMsg.m_pDescription6 = pCurrent->m_aDescription; break;
case 7: OptionMsg.m_pDescription7 = pCurrent->m_aDescription; break;
case 8: OptionMsg.m_pDescription8 = pCurrent->m_aDescription; break;
case 9: OptionMsg.m_pDescription9 = pCurrent->m_aDescription; break;
case 10: OptionMsg.m_pDescription10 = pCurrent->m_aDescription; break;
case 11: OptionMsg.m_pDescription11 = pCurrent->m_aDescription; break;
case 12: OptionMsg.m_pDescription12 = pCurrent->m_aDescription; break;
case 13: OptionMsg.m_pDescription13 = pCurrent->m_aDescription; break;
case 14:
{
OptionMsg.m_pDescription14 = pCurrent->m_aDescription;
OptionMsg.m_NumOptions = NumOptions;
Server()->SendPackMsg(&OptionMsg, MSGFLAG_VITAL, ClientID);
OptionMsg = CNetMsg_Sv_VoteOptionListAdd();
NumOptions = 0;
OptionMsg.m_pDescription1 = "";
OptionMsg.m_pDescription2 = "";
OptionMsg.m_pDescription3 = "";
OptionMsg.m_pDescription4 = "";
OptionMsg.m_pDescription5 = "";
OptionMsg.m_pDescription6 = "";
OptionMsg.m_pDescription7 = "";
OptionMsg.m_pDescription8 = "";
OptionMsg.m_pDescription9 = "";
OptionMsg.m_pDescription10 = "";
OptionMsg.m_pDescription11 = "";
OptionMsg.m_pDescription12 = "";
OptionMsg.m_pDescription13 = "";
OptionMsg.m_pDescription14 = "";
}
}
pCurrent = pCurrent->m_pNext;
}
if(NumOptions > 0)
{
OptionMsg.m_NumOptions = NumOptions;
Server()->SendPackMsg(&OptionMsg, MSGFLAG_VITAL, ClientID);
NumOptions = 0;
}
// send tuning parameters to client
SendTuningParams(ClientID);
// client is ready to enter
pPlayer->m_IsReady = true;
CNetMsg_Sv_ReadyToEnter m;
Server()->SendPackMsg(&m, MSGFLAG_VITAL|MSGFLAG_FLUSH, ClientID);
}
else if (MsgID == NETMSGTYPE_CL_CHANGEINFO)
{
if(g_Config.m_SvSpamprotection && pPlayer->m_LastChangeInfo && pPlayer->m_LastChangeInfo+Server()->TickSpeed()*5 > Server()->Tick())
return;
CNetMsg_Cl_ChangeInfo *pMsg = (CNetMsg_Cl_ChangeInfo *)pRawMsg;
pPlayer->m_LastChangeInfo = Server()->Tick();
// set infos
char aOldName[MAX_NAME_LENGTH];
str_copy(aOldName, Server()->ClientName(ClientID), sizeof(aOldName));
Server()->SetClientName(ClientID, pMsg->m_pName);
if(str_comp(aOldName, Server()->ClientName(ClientID)) != 0)
{
char aChatText[256];
str_format(aChatText, sizeof(aChatText), "'%s' changed name to '%s'", aOldName, Server()->ClientName(ClientID));
SendChat(-1, CGameContext::CHAT_ALL, aChatText);
}
Server()->SetClientClan(ClientID, pMsg->m_pClan);
Server()->SetClientCountry(ClientID, pMsg->m_Country);
str_copy(pPlayer->m_TeeInfos.m_SkinName, pMsg->m_pSkin, sizeof(pPlayer->m_TeeInfos.m_SkinName));
pPlayer->m_TeeInfos.m_UseCustomColor = pMsg->m_UseCustomColor;
pPlayer->m_TeeInfos.m_ColorBody = pMsg->m_ColorBody;
pPlayer->m_TeeInfos.m_ColorFeet = pMsg->m_ColorFeet;
m_pController->OnPlayerInfoChange(pPlayer);
}
else if (MsgID == NETMSGTYPE_CL_EMOTICON && !m_World.m_Paused)
{
CNetMsg_Cl_Emoticon *pMsg = (CNetMsg_Cl_Emoticon *)pRawMsg;
if(g_Config.m_SvSpamprotection && pPlayer->m_LastEmote && pPlayer->m_LastEmote+Server()->TickSpeed()*3 > Server()->Tick())
return;
pPlayer->m_LastEmote = Server()->Tick();
SendEmoticon(ClientID, pMsg->m_Emoticon);
}
else if (MsgID == NETMSGTYPE_CL_KILL && !m_World.m_Paused)
{
if(pPlayer->m_LastKill && pPlayer->m_LastKill+Server()->TickSpeed()*3 > Server()->Tick())
return;
pPlayer->m_LastKill = Server()->Tick();
pPlayer->KillCharacter(WEAPON_SELF);
}
}
void CGameContext::ConTuneParam(IConsole::IResult *pResult, void *pUserData)
{
CGameContext *pSelf = (CGameContext *)pUserData;
const char *pParamName = pResult->GetString(0);
float NewValue = pResult->GetFloat(1);
if(pSelf->Tuning()->Set(pParamName, NewValue))
{
char aBuf[256];
str_format(aBuf, sizeof(aBuf), "%s changed to %.2f", pParamName, NewValue);
pSelf->Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "tuning", aBuf);
pSelf->SendTuningParams(-1);
}
else
pSelf->Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "tuning", "No such tuning parameter");
}
void CGameContext::ConTuneReset(IConsole::IResult *pResult, void *pUserData)
{
CGameContext *pSelf = (CGameContext *)pUserData;
CTuningParams TuningParams;
*pSelf->Tuning() = TuningParams;
pSelf->SendTuningParams(-1);
pSelf->Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "tuning", "Tuning reset");
}
void CGameContext::ConTuneDump(IConsole::IResult *pResult, void *pUserData)
{
CGameContext *pSelf = (CGameContext *)pUserData;
char aBuf[256];
for(int i = 0; i < pSelf->Tuning()->Num(); i++)
{
float v;
pSelf->Tuning()->Get(i, &v);
str_format(aBuf, sizeof(aBuf), "%s %.2f", pSelf->Tuning()->m_apNames[i], v);
pSelf->Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "tuning", aBuf);
}
}
void CGameContext::ConPause(IConsole::IResult *pResult, void *pUserData)
{
CGameContext *pSelf = (CGameContext *)pUserData;
if(pSelf->m_pController->IsGameOver())
return;
pSelf->m_World.m_Paused ^= 1;
}
void CGameContext::ConChangeMap(IConsole::IResult *pResult, void *pUserData)
{
CGameContext *pSelf = (CGameContext *)pUserData;
pSelf->m_pController->ChangeMap(pResult->NumArguments() ? pResult->GetString(0) : "");
}
void CGameContext::ConRestart(IConsole::IResult *pResult, void *pUserData)
{
CGameContext *pSelf = (CGameContext *)pUserData;
if(pResult->NumArguments())
pSelf->m_pController->DoWarmup(pResult->GetInteger(0));
else
{
pSelf->m_pController->PostReset(true);
pSelf->m_pController->StartRound();
}
}
void CGameContext::ConBroadcast(IConsole::IResult *pResult, void *pUserData)
{
CGameContext *pSelf = (CGameContext *)pUserData;
pSelf->SendBroadcast(pResult->GetString(0), -1);
}
void CGameContext::ConSay(IConsole::IResult *pResult, void *pUserData)
{
CGameContext *pSelf = (CGameContext *)pUserData;
pSelf->SendChat(-1, CGameContext::CHAT_ALL, pResult->GetString(0));
}
void CGameContext::ConSetTeam(IConsole::IResult *pResult, void *pUserData)
{
CGameContext *pSelf = (CGameContext *)pUserData;
int ClientID = clamp(pResult->GetInteger(0), 0, (int)MAX_CLIENTS-1);
int Team = clamp(pResult->GetInteger(1), -1, 1);
int Delay = pResult->NumArguments()>2 ? pResult->GetInteger(2) : 0;
if(!pSelf->m_apPlayers[ClientID])
return;
char aBuf[256];
str_format(aBuf, sizeof(aBuf), "moved client %d to team %d", ClientID, Team);
pSelf->Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "server", aBuf);
pSelf->m_apPlayers[ClientID]->m_TeamChangeTick = pSelf->Server()->Tick()+pSelf->Server()->TickSpeed()*Delay*60;
pSelf->m_apPlayers[ClientID]->SetTeam(Team);
(void)pSelf->m_pController->CheckTeamBalance();
}
void CGameContext::ConSetTeamAll(IConsole::IResult *pResult, void *pUserData)
{
CGameContext *pSelf = (CGameContext *)pUserData;
int Team = clamp(pResult->GetInteger(0), -1, 1);
char aBuf[256];
str_format(aBuf, sizeof(aBuf), "All players were moved to the %s", pSelf->m_pController->GetTeamName(Team));
pSelf->SendChat(-1, CGameContext::CHAT_ALL, aBuf);
for(int i = 0; i < MAX_CLIENTS; ++i)
if(pSelf->m_apPlayers[i])
pSelf->m_apPlayers[i]->SetTeam(Team, false);
(void)pSelf->m_pController->CheckTeamBalance();
}
void CGameContext::ConSwapTeams(IConsole::IResult *pResult, void *pUserData)
{
CGameContext *pSelf = (CGameContext *)pUserData;
pSelf->SwapTeams();
}
void CGameContext::ConShuffleTeams(IConsole::IResult *pResult, void *pUserData)
{
CGameContext *pSelf = (CGameContext *)pUserData;
if(!pSelf->m_pController->IsTeamplay())
return;
int CounterRed = 0;
int CounterBlue = 0;
int PlayerTeam = 0;
for(int i = 0; i < MAX_CLIENTS; ++i)
if(pSelf->m_apPlayers[i] && pSelf->m_apPlayers[i]->GetTeam() != TEAM_SPECTATORS)
++PlayerTeam;
PlayerTeam = (PlayerTeam+1)/2;
pSelf->SendChat(-1, CGameContext::CHAT_ALL, "Teams were shuffled");
for(int i = 0; i < MAX_CLIENTS; ++i)
{
if(pSelf->m_apPlayers[i] && pSelf->m_apPlayers[i]->GetTeam() != TEAM_SPECTATORS)
{
if(CounterRed == PlayerTeam)
pSelf->m_apPlayers[i]->SetTeam(TEAM_BLUE, false);
else if(CounterBlue == PlayerTeam)
pSelf->m_apPlayers[i]->SetTeam(TEAM_RED, false);
else
{
if(rand() % 2)
{
pSelf->m_apPlayers[i]->SetTeam(TEAM_BLUE, false);
++CounterBlue;
}
else
{
pSelf->m_apPlayers[i]->SetTeam(TEAM_RED, false);
++CounterRed;
}
}
}
}
(void)pSelf->m_pController->CheckTeamBalance();
}
void CGameContext::ConLockTeams(IConsole::IResult *pResult, void *pUserData)
{
CGameContext *pSelf = (CGameContext *)pUserData;
pSelf->m_LockTeams ^= 1;
if(pSelf->m_LockTeams)
pSelf->SendChat(-1, CGameContext::CHAT_ALL, "Teams were locked");
else
pSelf->SendChat(-1, CGameContext::CHAT_ALL, "Teams were unlocked");
}
void CGameContext::ConAddVote(IConsole::IResult *pResult, void *pUserData)
{
CGameContext *pSelf = (CGameContext *)pUserData;
const char *pDescription = pResult->GetString(0);
const char *pCommand = pResult->GetString(1);
if(pSelf->m_NumVoteOptions == MAX_VOTE_OPTIONS)
{
pSelf->Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "server", "maximum number of vote options reached");
return;
}
// check for valid option
if(!pSelf->Console()->LineIsValid(pCommand) || str_length(pCommand) >= VOTE_CMD_LENGTH)
{
char aBuf[256];
str_format(aBuf, sizeof(aBuf), "skipped invalid command '%s'", pCommand);
pSelf->Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "server", aBuf);
return;
}
while(*pDescription && *pDescription == ' ')
pDescription++;
if(str_length(pDescription) >= VOTE_DESC_LENGTH || *pDescription == 0)
{
char aBuf[256];
str_format(aBuf, sizeof(aBuf), "skipped invalid option '%s'", pDescription);
pSelf->Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "server", aBuf);
return;
}
// check for duplicate entry
CVoteOptionServer *pOption = pSelf->m_pVoteOptionFirst;
while(pOption)
{
if(str_comp_nocase(pDescription, pOption->m_aDescription) == 0)
{
char aBuf[256];
str_format(aBuf, sizeof(aBuf), "option '%s' already exists", pDescription);
pSelf->Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "server", aBuf);
return;
}
pOption = pOption->m_pNext;
}
// add the option
++pSelf->m_NumVoteOptions;
int Len = str_length(pCommand);
pOption = (CVoteOptionServer *)pSelf->m_pVoteOptionHeap->Allocate(sizeof(CVoteOptionServer) + Len);
pOption->m_pNext = 0;
pOption->m_pPrev = pSelf->m_pVoteOptionLast;
if(pOption->m_pPrev)
pOption->m_pPrev->m_pNext = pOption;
pSelf->m_pVoteOptionLast = pOption;
if(!pSelf->m_pVoteOptionFirst)
pSelf->m_pVoteOptionFirst = pOption;
str_copy(pOption->m_aDescription, pDescription, sizeof(pOption->m_aDescription));
mem_copy(pOption->m_aCommand, pCommand, Len+1);
char aBuf[256];
str_format(aBuf, sizeof(aBuf), "added option '%s' '%s'", pOption->m_aDescription, pOption->m_aCommand);
pSelf->Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "server", aBuf);
// inform clients about added option
CNetMsg_Sv_VoteOptionAdd OptionMsg;
OptionMsg.m_pDescription = pOption->m_aDescription;
pSelf->Server()->SendPackMsg(&OptionMsg, MSGFLAG_VITAL, -1);
}
void CGameContext::ConRemoveVote(IConsole::IResult *pResult, void *pUserData)
{
CGameContext *pSelf = (CGameContext *)pUserData;
const char *pDescription = pResult->GetString(0);
// check for valid option
CVoteOptionServer *pOption = pSelf->m_pVoteOptionFirst;
while(pOption)
{
if(str_comp_nocase(pDescription, pOption->m_aDescription) == 0)
break;
pOption = pOption->m_pNext;
}
if(!pOption)
{
char aBuf[256];
str_format(aBuf, sizeof(aBuf), "option '%s' does not exist", pDescription);
pSelf->Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "server", aBuf);
return;
}
// inform clients about removed option
CNetMsg_Sv_VoteOptionRemove OptionMsg;
OptionMsg.m_pDescription = pOption->m_aDescription;
pSelf->Server()->SendPackMsg(&OptionMsg, MSGFLAG_VITAL, -1);
// TODO: improve this
// remove the option
--pSelf->m_NumVoteOptions;
char aBuf[256];
str_format(aBuf, sizeof(aBuf), "removed option '%s' '%s'", pOption->m_aDescription, pOption->m_aCommand);
pSelf->Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "server", aBuf);
CHeap *pVoteOptionHeap = new CHeap();
CVoteOptionServer *pVoteOptionFirst = 0;
CVoteOptionServer *pVoteOptionLast = 0;
int NumVoteOptions = pSelf->m_NumVoteOptions;
for(CVoteOptionServer *pSrc = pSelf->m_pVoteOptionFirst; pSrc; pSrc = pSrc->m_pNext)
{
if(pSrc == pOption)
continue;
// copy option
int Len = str_length(pSrc->m_aCommand);
CVoteOptionServer *pDst = (CVoteOptionServer *)pVoteOptionHeap->Allocate(sizeof(CVoteOptionServer) + Len);
pDst->m_pNext = 0;
pDst->m_pPrev = pVoteOptionLast;
if(pDst->m_pPrev)
pDst->m_pPrev->m_pNext = pDst;
pVoteOptionLast = pDst;
if(!pVoteOptionFirst)
pVoteOptionFirst = pDst;
str_copy(pDst->m_aDescription, pSrc->m_aDescription, sizeof(pDst->m_aDescription));
mem_copy(pDst->m_aCommand, pSrc->m_aCommand, Len+1);
}
// clean up
delete pSelf->m_pVoteOptionHeap;
pSelf->m_pVoteOptionHeap = pVoteOptionHeap;
pSelf->m_pVoteOptionFirst = pVoteOptionFirst;
pSelf->m_pVoteOptionLast = pVoteOptionLast;
pSelf->m_NumVoteOptions = NumVoteOptions;
}
void CGameContext::ConForceVote(IConsole::IResult *pResult, void *pUserData)
{
CGameContext *pSelf = (CGameContext *)pUserData;
const char *pType = pResult->GetString(0);
const char *pValue = pResult->GetString(1);
const char *pReason = pResult->NumArguments() > 2 && pResult->GetString(2)[0] ? pResult->GetString(2) : "No reason given";
char aBuf[128] = {0};
if(str_comp_nocase(pType, "option") == 0)
{
CVoteOptionServer *pOption = pSelf->m_pVoteOptionFirst;
while(pOption)
{
if(str_comp_nocase(pValue, pOption->m_aDescription) == 0)
{
str_format(aBuf, sizeof(aBuf), "admin forced server option '%s' (%s)", pValue, pReason);
pSelf->SendChatTarget(-1, aBuf);
pSelf->Console()->ExecuteLine(pOption->m_aCommand);
break;
}
pOption = pOption->m_pNext;
}
if(!pOption)
{
str_format(aBuf, sizeof(aBuf), "'%s' isn't an option on this server", pValue);
pSelf->Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "server", aBuf);
return;
}
}
else if(str_comp_nocase(pType, "kick") == 0)
{
int KickID = str_toint(pValue);
if(KickID < 0 || KickID >= MAX_CLIENTS || !pSelf->m_apPlayers[KickID])
{
pSelf->Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "server", "Invalid client id to kick");
return;
}
if (!g_Config.m_SvVoteKickBantime)
{
str_format(aBuf, sizeof(aBuf), "kick %d %s", KickID, pReason);
pSelf->Console()->ExecuteLine(aBuf);
}
else
{
char aAddrStr[NETADDR_MAXSTRSIZE] = {0};
pSelf->Server()->GetClientAddr(KickID, aAddrStr, sizeof(aAddrStr));
str_format(aBuf, sizeof(aBuf), "ban %s %d %s", aAddrStr, g_Config.m_SvVoteKickBantime, pReason);
pSelf->Console()->ExecuteLine(aBuf);
}
}
else if(str_comp_nocase(pType, "spectate") == 0)
{
int SpectateID = str_toint(pValue);
if(SpectateID < 0 || SpectateID >= MAX_CLIENTS || !pSelf->m_apPlayers[SpectateID] || pSelf->m_apPlayers[SpectateID]->GetTeam() == TEAM_SPECTATORS)
{
pSelf->Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "server", "Invalid client id to move");
return;
}
str_format(aBuf, sizeof(aBuf), "admin moved '%s' to spectator (%s)", pSelf->Server()->ClientName(SpectateID), pReason);
pSelf->SendChatTarget(-1, aBuf);
str_format(aBuf, sizeof(aBuf), "set_team %d -1 %d", SpectateID, g_Config.m_SvVoteSpectateRejoindelay);
pSelf->Console()->ExecuteLine(aBuf);
}
}
void CGameContext::ConClearVotes(IConsole::IResult *pResult, void *pUserData)
{
CGameContext *pSelf = (CGameContext *)pUserData;
pSelf->Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "server", "cleared votes");
CNetMsg_Sv_VoteClearOptions VoteClearOptionsMsg;
pSelf->Server()->SendPackMsg(&VoteClearOptionsMsg, MSGFLAG_VITAL, -1);
pSelf->m_pVoteOptionHeap->Reset();
pSelf->m_pVoteOptionFirst = 0;
pSelf->m_pVoteOptionLast = 0;
pSelf->m_NumVoteOptions = 0;
}
void CGameContext::ConVote(IConsole::IResult *pResult, void *pUserData)
{
CGameContext *pSelf = (CGameContext *)pUserData;
// check if there is a vote running
if(!pSelf->m_VoteCloseTime)
return;
if(str_comp_nocase(pResult->GetString(0), "yes") == 0)
pSelf->m_VoteEnforce = CGameContext::VOTE_ENFORCE_YES;
else if(str_comp_nocase(pResult->GetString(0), "no") == 0)
pSelf->m_VoteEnforce = CGameContext::VOTE_ENFORCE_NO;
char aBuf[256];
str_format(aBuf, sizeof(aBuf), "admin forced vote %s", pResult->GetString(0));
pSelf->SendChatTarget(-1, aBuf);
str_format(aBuf, sizeof(aBuf), "forcing vote %s", pResult->GetString(0));
pSelf->Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "server", aBuf);
}
void CGameContext::ConchainSpecialMotdupdate(IConsole::IResult *pResult, void *pUserData, IConsole::FCommandCallback pfnCallback, void *pCallbackUserData)
{
pfnCallback(pResult, pCallbackUserData);
if(pResult->NumArguments())
{
CNetMsg_Sv_Motd Msg;
Msg.m_pMessage = g_Config.m_SvMotd;
CGameContext *pSelf = (CGameContext *)pUserData;
for(int i = 0; i < MAX_CLIENTS; ++i)
if(pSelf->m_apPlayers[i])
pSelf->Server()->SendPackMsg(&Msg, MSGFLAG_VITAL, i);
}
}
void CGameContext::OnConsoleInit()
{
m_pServer = Kernel()->RequestInterface<IServer>();
m_pConsole = Kernel()->RequestInterface<IConsole>();
Console()->Register("tune", "si", CFGFLAG_SERVER, ConTuneParam, this, "Tune variable to value");
Console()->Register("tune_reset", "", CFGFLAG_SERVER, ConTuneReset, this, "Reset tuning");
Console()->Register("tune_dump", "", CFGFLAG_SERVER, ConTuneDump, this, "Dump tuning");
Console()->Register("pause", "", CFGFLAG_SERVER, ConPause, this, "Pause/unpause game");
Console()->Register("change_map", "?r", CFGFLAG_SERVER|CFGFLAG_STORE, ConChangeMap, this, "Change map");
Console()->Register("restart", "?i", CFGFLAG_SERVER|CFGFLAG_STORE, ConRestart, this, "Restart in x seconds (0 = abort)");
Console()->Register("broadcast", "r", CFGFLAG_SERVER, ConBroadcast, this, "Broadcast message");
Console()->Register("say", "r", CFGFLAG_SERVER, ConSay, this, "Say in chat");
Console()->Register("set_team", "ii?i", CFGFLAG_SERVER, ConSetTeam, this, "Set team of player to team");
Console()->Register("set_team_all", "i", CFGFLAG_SERVER, ConSetTeamAll, this, "Set team of all players to team");
Console()->Register("swap_teams", "", CFGFLAG_SERVER, ConSwapTeams, this, "Swap the current teams");
Console()->Register("shuffle_teams", "", CFGFLAG_SERVER, ConShuffleTeams, this, "Shuffle the current teams");
Console()->Register("lock_teams", "", CFGFLAG_SERVER, ConLockTeams, this, "Lock/unlock teams");
Console()->Register("add_vote", "sr", CFGFLAG_SERVER, ConAddVote, this, "Add a voting option");
Console()->Register("remove_vote", "s", CFGFLAG_SERVER, ConRemoveVote, this, "remove a voting option");
Console()->Register("force_vote", "ss?r", CFGFLAG_SERVER, ConForceVote, this, "Force a voting option");
Console()->Register("clear_votes", "", CFGFLAG_SERVER, ConClearVotes, this, "Clears the voting options");
Console()->Register("vote", "r", CFGFLAG_SERVER, ConVote, this, "Force a vote to yes/no");
Console()->Chain("sv_motd", ConchainSpecialMotdupdate, this);
}
void CGameContext::OnInit(/*class IKernel *pKernel*/)
{
m_pServer = Kernel()->RequestInterface<IServer>();
m_pConsole = Kernel()->RequestInterface<IConsole>();
m_World.SetGameServer(this);
m_Events.SetGameServer(this);
//if(!data) // only load once
//data = load_data_from_memory(internal_data);
for(int i = 0; i < NUM_NETOBJTYPES; i++)
Server()->SnapSetStaticsize(i, m_NetObjHandler.GetObjSize(i));
m_Layers.Init(Kernel());
m_Collision.Init(&m_Layers);
// reset everything here
//world = new GAMEWORLD;
//players = new CPlayer[MAX_CLIENTS];
// select gametype
if(str_comp(g_Config.m_SvGametype, "mod") == 0)
m_pController = new CGameControllerMOD(this);
else if(str_comp(g_Config.m_SvGametype, "ctf") == 0)
m_pController = new CGameControllerCTF(this);
else if(str_comp(g_Config.m_SvGametype, "tdm") == 0)
m_pController = new CGameControllerTDM(this);
else if(str_comp(g_Config.m_SvGametype, "survtdm") == 0)
m_pController = new CGameControllerSURVTDM(this);
else if(str_comp(g_Config.m_SvGametype, "survdm") == 0)
m_pController = new CGameControllerSURVDM(this);
else
m_pController = new CGameControllerDM(this);
// setup core world
//for(int i = 0; i < MAX_CLIENTS; i++)
// game.players[i].core.world = &game.world.core;
// create all entities from the game layer
CMapItemLayerTilemap *pTileMap = m_Layers.GameLayer();
CTile *pTiles = (CTile *)Kernel()->RequestInterface<IMap>()->GetData(pTileMap->m_Data);
/*
num_spawn_points[0] = 0;
num_spawn_points[1] = 0;
num_spawn_points[2] = 0;
*/
for(int y = 0; y < pTileMap->m_Height; y++)
{
for(int x = 0; x < pTileMap->m_Width; x++)
{
int Index = pTiles[y*pTileMap->m_Width+x].m_Index;
if(Index >= ENTITY_OFFSET)
{
vec2 Pos(x*32.0f+16.0f, y*32.0f+16.0f);
m_pController->OnEntity(Index-ENTITY_OFFSET, Pos);
}
}
}
//game.world.insert_entity(game.Controller);
#ifdef CONF_DEBUG
if(g_Config.m_DbgDummies)
{
for(int i = 0; i < g_Config.m_DbgDummies ; i++)
{
OnClientConnected(MAX_CLIENTS-i-1);
}
}
#endif
}
void CGameContext::OnShutdown()
{
delete m_pController;
m_pController = 0;
Clear();
}
void CGameContext::OnSnap(int ClientID)
{
// add tuning to demo
CTuningParams StandardTuning;
if(ClientID == -1 && Server()->DemoRecorder_IsRecording() && mem_comp(&StandardTuning, &m_Tuning, sizeof(CTuningParams)) != 0)
{
CMsgPacker Msg(NETMSGTYPE_SV_TUNEPARAMS);
int *pParams = (int *)&m_Tuning;
for(unsigned i = 0; i < sizeof(m_Tuning)/sizeof(int); i++)
Msg.AddInt(pParams[i]);
Server()->SendMsg(&Msg, MSGFLAG_RECORD|MSGFLAG_NOSEND, ClientID);
}
m_World.Snap(ClientID);
m_pController->Snap(ClientID);
m_Events.Snap(ClientID);
for(int i = 0; i < MAX_CLIENTS; i++)
{
if(m_apPlayers[i])
m_apPlayers[i]->Snap(ClientID);
}
}
void CGameContext::OnPreSnap() {}
void CGameContext::OnPostSnap()
{
m_Events.Clear();
}
bool CGameContext::IsClientReady(int ClientID)
{
return m_apPlayers[ClientID] && m_apPlayers[ClientID]->m_IsReady ? true : false;
}
bool CGameContext::IsClientPlayer(int ClientID)
{
return m_apPlayers[ClientID] && m_apPlayers[ClientID]->GetTeam() == TEAM_SPECTATORS ? false : true;
}
const char *CGameContext::GameType() { return m_pController && m_pController->m_pGameType ? m_pController->m_pGameType : ""; }
const char *CGameContext::Version() { return GAME_VERSION; }
const char *CGameContext::NetVersion() { return GAME_NETVERSION; }
IGameServer *CreateGameServer() { return new CGameContext; }
|
/*
* Copyright (c) 2017, Intel Corporation
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*/
L0:
mov (8|M0) r16.0<1>:ud r0.0<8;8,1>:ud
(W&~f0.1)jmpi L352
L32:
mov (8|M0) r17.0<1>:ud r25.0<8;8,1>:ud
add (1|M0) a0.0<1>:ud r23.5<0;1,0>:ud 0x42EC130:ud
mov (1|M0) r16.2<1>:ud 0xE000:ud
send (1|M0) r80:uw r16:ub 0x2 a0.0
mov (1|M0) r17.2<1>:f r10.1<0;1,0>:f
send (1|M0) r88:uw r16:ub 0x2 a0.0
add (1|M0) a0.0<1>:ud r23.5<0;1,0>:ud 0x44EC231:ud
mov (1|M0) r17.2<1>:f r25.2<0;1,0>:f
mov (1|M0) r16.2<1>:ud 0xC000:ud
send (1|M0) r84:uw r16:ub 0x2 a0.0
mov (1|M0) r17.2<1>:f r10.1<0;1,0>:f
send (1|M0) r92:uw r16:ub 0x2 a0.0
mov (16|M0) r82.0<1>:uw 0xFFFF:uw
mov (16|M0) r83.0<1>:uw 0xFFFF:uw
mov (16|M0) r90.0<1>:uw 0xFFFF:uw
mov (16|M0) r91.0<1>:uw 0xFFFF:uw
mov (1|M0) a0.8<1>:uw 0xA00:uw
mov (1|M0) a0.9<1>:uw 0xA80:uw
mov (1|M0) a0.10<1>:uw 0xAC0:uw
add (4|M0) a0.12<1>:uw a0.8<4;4,1>:uw 0x100:uw
L352:
nop
|
; A246360: a(1) = 1, then A007051 ((3^n)+1)/2 interleaved with A057198 (5*3^(n-1)+1)/2.
; 1,2,3,5,8,14,23,41,68,122,203,365,608,1094,1823,3281,5468,9842,16403,29525,49208,88574,147623,265721,442868,797162,1328603,2391485,3985808,7174454,11957423,21523361,35872268,64570082,107616803,193710245,322850408,581130734
add $0,2
mov $2,1
lpb $0
sub $0,1
trn $1,2
add $1,$2
mov $2,$1
sub $1,$0
trn $1,2
add $1,1
add $2,$1
lpe
|
; A121048: n + phi(n), for Euler totient function phi(n).
; 2,3,5,6,9,8,13,12,15,14,21,16,25,20,23,24,33,24,37,28,33,32,45,32,45,38,45,40,57,38,61,48,53,50,59,48,73,56,63,56,81,54,85,64,69,68,93,64,91,70,83,76,105,72,95,80,93,86,117,76,121,92,99,96,113,86,133,100,113,94,141,96,145,110,115,112,137,102,157,112,135,122,165,108,149,128,143,128,177,114,163,136,153,140,167,128,193,140,159,140,201,134,205,152,153,158,213,144,217,150,183,160,225,150,203,172,189,176,215,152,231,182,203,184,225,162,253,192,213,178,261,172,241,200,207,200,273,182,277,188,233,212,263,192,257,218,231,220,297,190,301,224,249,214,275,204,313,236,263,224,293,216,325,244,245,248,333,216,325,234,279,256,345,230,295,256,293,266,357,228,361,254,303,272,329,246,347,280,297,262,381,256,385,290,291,280,393,258,397,280,333,302,371,268,365,308,339,304,389,258,421,316,353,320,383,288,397,326,363,300,413,294,445,320,345,338,453,300,457,318,351,344,465,306,419,352,393,334,477,304,481,352,405,364,413,326,463,368,413,350
mov $1,$0
cal $0,10 ; Euler totient function phi(n): count numbers <= n and prime to n.
add $1,$0
add $1,1
|
; Routine to set HOTKEY item V2.02 1988 Tony Tebby QJUMP
section hotkey
xdef hot_seti
xdef hot_sets
xref hot_gtky
xref hot_thact
xref hot_rter
xref hk_newst
xref ut_gxnm1
xref ut_gtnm1
xref gu_achpp
xref gu_rchp
include 'dev8_keys_err'
include 'dev8_ee_hk_data'
;+++
; Set simple hotkey item, and return to basic
;
; d6 c s hotkey item type
;---
hot_seti
jsr hot_gtky ; first the key
bne.s hs_rts
jsr ut_gxnm1 ; get second string
bne.s hs_rts
;+++
; Set simple hotkey item, and return to basic
;
; d6 c s hotkey item type
; d7 c s Hotkey
; a1 c p pointer to item name string (a6,a1.l)
;---
hot_sets
move.w (a6,a1.l),d1 ; length of name
moveq #hki_name+2,d0 ; allocate space for item
add.w d1,d0
jsr gu_achpp
bne.s hs_rter
move.l a1,a2 ; name pointer
move.l a0,a1 ; item base
move.w #hki.id,(a0)+ ; ID
move.w d6,(a0)+ ; and type
clr.l (a0)+ ; pointer
move.w d1,(a0)+ ; name length
hs_nmloop
move.b 2(a6,a2.l),(a0)+ ; and the rest of the name
addq.l #1,a2
subq.w #1,d1
bgt.s hs_nmloop
lea hk_newst,a2 ; set new hotkey
move.w d7,d1 ; key
jsr hot_thact ; action
beq.s hs_rter
move.l a1,a0 ; remove item
jsr gu_rchp
hs_rter
jmp hot_rter
hs_rts
rts
end
|
; vim: set syntax=z80:
#local
#code _CODE
; Stores corresponding addresses of scanlines
.align 512
scanline_table:
dw 0x4000
dw 0x4100
dw 0x4200
dw 0x4300
dw 0x4400
dw 0x4500
dw 0x4600
dw 0x4700
dw 0x4020
dw 0x4120
dw 0x4220
dw 0x4320
dw 0x4420
dw 0x4520
dw 0x4620
dw 0x4720
dw 0x4040
dw 0x4140
dw 0x4240
dw 0x4340
dw 0x4440
dw 0x4540
dw 0x4640
dw 0x4740
dw 0x4060
dw 0x4160
dw 0x4260
dw 0x4360
dw 0x4460
dw 0x4560
dw 0x4660
dw 0x4760
dw 0x4080
dw 0x4180
dw 0x4280
dw 0x4380
dw 0x4480
dw 0x4580
dw 0x4680
dw 0x4780
dw 0x40A0
dw 0x41A0
dw 0x42A0
dw 0x43A0
dw 0x44A0
dw 0x45A0
dw 0x46A0
dw 0x47A0
dw 0x40C0
dw 0x41C0
dw 0x42C0
dw 0x43C0
dw 0x44C0
dw 0x45C0
dw 0x46C0
dw 0x47C0
dw 0x40E0
dw 0x41E0
dw 0x42E0
dw 0x43E0
dw 0x44E0
dw 0x45E0
dw 0x46E0
dw 0x47E0
dw 0x4800
dw 0x4900
dw 0x4A00
dw 0x4B00
dw 0x4C00
dw 0x4D00
dw 0x4E00
dw 0x4F00
dw 0x4820
dw 0x4920
dw 0x4A20
dw 0x4B20
dw 0x4C20
dw 0x4D20
dw 0x4E20
dw 0x4F20
dw 0x4840
dw 0x4940
dw 0x4A40
dw 0x4B40
dw 0x4C40
dw 0x4D40
dw 0x4E40
dw 0x4F40
dw 0x4860
dw 0x4960
dw 0x4A60
dw 0x4B60
dw 0x4C60
dw 0x4D60
dw 0x4E60
dw 0x4F60
dw 0x4880
dw 0x4980
dw 0x4A80
dw 0x4B80
dw 0x4C80
dw 0x4D80
dw 0x4E80
dw 0x4F80
dw 0x48A0
dw 0x49A0
dw 0x4AA0
dw 0x4BA0
dw 0x4CA0
dw 0x4DA0
dw 0x4EA0
dw 0x4FA0
dw 0x48C0
dw 0x49C0
dw 0x4AC0
dw 0x4BC0
dw 0x4CC0
dw 0x4DC0
dw 0x4EC0
dw 0x4FC0
dw 0x48E0
dw 0x49E0
dw 0x4AE0
dw 0x4BE0
dw 0x4CE0
dw 0x4DE0
dw 0x4EE0
dw 0x4FE0
dw 0x5000
dw 0x5100
dw 0x5200
dw 0x5300
dw 0x5400
dw 0x5500
dw 0x5600
dw 0x5700
dw 0x5020
dw 0x5120
dw 0x5220
dw 0x5320
dw 0x5420
dw 0x5520
dw 0x5620
dw 0x5720
dw 0x5040
dw 0x5140
dw 0x5240
dw 0x5340
dw 0x5440
dw 0x5540
dw 0x5640
dw 0x5740
dw 0x5060
dw 0x5160
dw 0x5260
dw 0x5360
dw 0x5460
dw 0x5560
dw 0x5660
dw 0x5760
dw 0x5080
dw 0x5180
dw 0x5280
dw 0x5380
dw 0x5480
dw 0x5580
dw 0x5680
dw 0x5780
dw 0x50A0
dw 0x51A0
dw 0x52A0
dw 0x53A0
dw 0x54A0
dw 0x55A0
dw 0x56A0
dw 0x57A0
dw 0x50C0
dw 0x51C0
dw 0x52C0
dw 0x53C0
dw 0x54C0
dw 0x55C0
dw 0x56C0
dw 0x57C0
dw 0x50E0
dw 0x51E0
dw 0x52E0
dw 0x53E0
dw 0x54E0
dw 0x55E0
dw 0x56E0
dw 0x57E0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; void plot_point(unsigned char x, unsigned char y) ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
#local
_plot_point::
pop af
pop bc
push bc
push af
_plot_point_fastcall::
; load scanline address
ld l, b
ld h, scanline_table >> 9
add hl, hl
ld e, (hl)
inc hl
ld d, (hl)
; horizontal offset
ld a, c
and 0xF8
rrca
rrca
rrca
or e
ld e, a
; load a with bit to set
ld h, _BitmapBits >> 8
ld a, c
and 0x07
ld l, a
ld a, (hl)
; write bit
ex de, hl
or (hl)
ld (hl), a
ret
#endlocal
.align 256
_BitmapBits::
db 0x80
db 0x40
db 0x20
db 0x10
db 0x08
db 0x04
db 0x02
db 0x01
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; void plot_line(byte x1, byte y1, byte x2, byte y2) ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Bresenham's Algorithm
_plot_line:
#local
; l = x1, h = y1, e = x2, d = y2
pop af
pop hl
pop de
push de
push hl
push af
push ix
ld ix, 0
add ix, sp
; ensure vectors are in left-to-right order
ld a, e
sub l
jr nc, correct_order
ex de, hl
neg
correct_order:
push hl
ld b, a
; if y1 > y2
ld a, d
sub h
jr c, negative_gradient
; non-negative gradient
; store dx, dy
ld c, a
push bc
cp b
jr nc, dy_ge_1
; dx > dy
; TODO
dy_ge_1:
; dy >= dx
; store 2dx-2dy, 2dx
ld a, b
sub c
add a, a
ld c, a
ld a, b
add a, a
ld b, a
push bc
; store decision variable, loop counter
ld c, (ix-4)
sub c
ld b, a
dec c
push bc
; draw first pixel
ld c, l
ld b, h
call _plot_point_fastcall
cont2:
; check decision variable
ld a, (ix-7)
add a, a
jr nc, decision_ge_zero2
; p < 0
; plot_point(x, ++y)
ld c, (ix-2)
ld b, (ix-1)
inc b
ld (ix-1), b
call _plot_point_fastcall
; p += 2dx
ld a, (ix-7)
add a, (ix-6)
ld (ix-7), a
jp decision_end2
decision_ge_zero2:
; pk >= 0
; plot_point(++x, ++y)
ld c, (ix-2)
inc c
ld (ix-2), c
ld b, (ix-1)
inc b
ld (ix-1), b
call _plot_point_fastcall
; p += 2dx - 2dy
ld a, (ix-7)
add a, (ix-5)
ld (ix-7), a
decision_end2:
dec (ix-8)
jr nz, cont2
ld sp, ix
pop ix
ret
negative_gradient:
; negative gradient
; store dx, dy
neg
ld c, a
push bc
; TODO
#endlocal
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Byte *GetDisplay(Byte x, Byte y) ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
#local
_GetDisplay::
pop af
pop bc ; b = $y, c = $x
push bc
push af
; load scanline address
ld l, b
ld h, scanline_table >> 9
add hl, hl
ld e, (hl)
inc hl
ld d, (hl)
; horizontal offset
ld a, c
and 0xF8
rrca
rrca
rrca
or e
ld e, a
ex de, hl
ret
#endlocal
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Byte GetDisplayMask(Byte x) ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
#local
_GetDisplayMask::
pop af
dec sp
pop bc ; b = $x
push bc
inc sp
push af
ld h, _BitmapBits >> 8
ld a, b
and 0x07
ld l, a
ld l, (hl)
ret
#endlocal
#endlocal
|
INCLUDE "config_private.inc"
SECTION code_driver
EXTERN _acia_reset, aciaControl
PUBLIC _acia_init
_acia_init:
; initialise the ACIA
ld a,__IO_ACIA_CR_RESET ; Master Reset the ACIA
out (__IO_ACIA_CONTROL_REGISTER),a
ld a,__IO_ACIA_CR_REI|__IO_ACIA_CR_TDI_RTS0|__IO_ACIA_CR_8N2|__IO_ACIA_CR_CLK_DIV_64
; load the default ACIA configuration
; 8n2 at 115200 baud
; receive interrupt enabled
; transmit interrupt disabled
ld (aciaControl),a ; write the ACIA control byte echo
out (__IO_ACIA_CONTROL_REGISTER),a ; output to the ACIA control
jp _acia_reset ; reset empties the Tx & Rx buffers
|
;------------------------------------------------------------------------------
;
; Copyright (c) 2006 - 2008, Intel Corporation. All rights reserved.<BR>
; SPDX-License-Identifier: BSD-2-Clause-Patent
;
; Module Name:
;
; EnableCache.Asm
;
; Abstract:
;
; Flush all caches with a WBINVD instruction, clear the CD bit of CR0 to 0, and clear
; the NW bit of CR0 to 0
;
; Notes:
;
;------------------------------------------------------------------------------
DEFAULT REL
SECTION .text
;------------------------------------------------------------------------------
; VOID
; EFIAPI
; AsmEnableCache (
; VOID
; );
;------------------------------------------------------------------------------
global ASM_PFX(AsmEnableCache)
ASM_PFX(AsmEnableCache):
wbinvd
mov rax, cr0
btr rax, 29
btr rax, 30
mov cr0, rax
ret
|
.MODEL SMALL
.STACK 100H
.DATA
PROMPT_1 DB 'ENTER THE BINARY NUM: $'
PROMPT_2 DB 0DH, 0AH, 'GIVEN BINARY NUM IN REV ORDER: $'
.CODE
MAIN PROC
MOV AX, @DATA
MOV DS, AX
LEA DX, PROMPT_1
MOV AH, 9
INT 21H
XOR BL, BL
MOV CX, 8
MOV AH, 1
@INPUT:
INT 21H
CMP AL, 0DH
JE @END
AND AL, 0FH
SHL BL, 1
OR BL, AL
LOOP @INPUT
@END:
MOV AL, BL
MOV CX, 8
@LOOP:
SHL AL, 1
RCR BL, 1
LOOP @LOOP
LEA DX, PROMPT_2
MOV AH, 9
INT 21H
MOV CX, 8
MOV AH, 2
@OUTPUT:
SHL BL, 1
JNC @ZERO
MOV DL, 31H
JMP @PRINT
@ZERO:
MOV DL, 30H
@PRINT:
INT 21H
LOOP @OUTPUT
MOV AH, 4CH
INT 21H
MAIN ENDP
END MAIN
|
/**
* PANDA 3D SOFTWARE
* Copyright (c) Carnegie Mellon University. All rights reserved.
*
* All use of this software is subject to the terms of the revised BSD
* license. You should have received a copy of this license along
* with this source code in a file named "LICENSE."
*
* @file ropeNode.cxx
* @author drose
* @date 2002-12-04
*/
#include "ropeNode.h"
#include "cullTraverser.h"
#include "cullTraverserData.h"
#include "cullableObject.h"
#include "cullHandler.h"
#include "renderState.h"
#include "renderModeAttrib.h"
#include "colorAttrib.h"
#include "bamWriter.h"
#include "bamReader.h"
#include "datagram.h"
#include "datagramIterator.h"
#include "pStatTimer.h"
#include "geom.h"
#include "geomLines.h"
#include "geomTristrips.h"
#include "geomVertexWriter.h"
#include "boundingSphere.h"
TypeHandle RopeNode::_type_handle;
PStatCollector RopeNode::_rope_node_pcollector("*:RopeNode");
/**
*
*/
CycleData *RopeNode::CData::
make_copy() const {
return new CData(*this);
}
/**
* Writes the contents of this object to the datagram for shipping out to a
* Bam file.
*/
void RopeNode::CData::
write_datagram(BamWriter *writer, Datagram &dg) const {
// For now, we write a NULL pointer. Eventually we will write out the
// NurbsCurveEvaluator pointer.
writer->write_pointer(dg, nullptr);
}
/**
* This internal function is called by make_from_bam to read in all of the
* relevant data from the BamFile for the new RopeNode.
*/
void RopeNode::CData::
fillin(DatagramIterator &scan, BamReader *reader) {
// For now, we skip over the NULL pointer that we wrote out.
reader->skip_pointer(scan);
}
/**
*
*/
RopeNode::
RopeNode(const std::string &name) :
PandaNode(name)
{
set_cull_callback();
}
/**
*
*/
RopeNode::
RopeNode(const RopeNode ©) :
PandaNode(copy),
_cycler(copy._cycler)
{
}
/**
* Returns a newly-allocated Node that is a shallow copy of this one. It will
* be a different Node pointer, but its internal data may or may not be shared
* with that of the original Node.
*/
PandaNode *RopeNode::
make_copy() const {
return new RopeNode(*this);
}
/**
* Returns true if it is generally safe to transform this particular kind of
* Node by calling the xform() method, false otherwise. For instance, it's
* usually a bad idea to attempt to xform a RopeNode.
*/
bool RopeNode::
safe_to_transform() const {
return false;
}
/**
* This function will be called during the cull traversal to perform any
* additional operations that should be performed at cull time. This may
* include additional manipulation of render state or additional
* visible/invisible decisions, or any other arbitrary operation.
*
* Note that this function will *not* be called unless set_cull_callback() is
* called in the constructor of the derived class. It is necessary to call
* set_cull_callback() to indicated that we require cull_callback() to be
* called.
*
* By the time this function is called, the node has already passed the
* bounding-volume test for the viewing frustum, and the node's transform and
* state have already been applied to the indicated CullTraverserData object.
*
* The return value is true if this node should be visible, or false if it
* should be culled.
*/
bool RopeNode::
cull_callback(CullTraverser *trav, CullTraverserData &data) {
// Statistics
PStatTimer timer(_rope_node_pcollector);
// Create some geometry on-the-fly to render the rope.
if (get_num_subdiv() > 0) {
NurbsCurveEvaluator *curve = get_curve();
if (curve != nullptr) {
PT(NurbsCurveResult) result;
if (has_matrix()) {
result = curve->evaluate(data.get_node_path(), get_matrix());
} else {
result = curve->evaluate(data.get_node_path());
}
if (result->get_num_segments() > 0) {
switch (get_render_mode()) {
case RM_thread:
render_thread(trav, data, result);
break;
case RM_tape:
render_tape(trav, data, result);
break;
case RM_billboard:
render_billboard(trav, data, result);
break;
case RM_tube:
render_tube(trav, data, result);
break;
}
}
}
}
return true;
}
/**
* Returns true if there is some value to visiting this particular node during
* the cull traversal for any camera, false otherwise. This will be used to
* optimize the result of get_net_draw_show_mask(), so that any subtrees that
* contain only nodes for which is_renderable() is false need not be visited.
*/
bool RopeNode::
is_renderable() const {
return true;
}
/**
*
*/
void RopeNode::
output(std::ostream &out) const {
PandaNode::output(out);
NurbsCurveEvaluator *curve = get_curve();
if (curve != nullptr) {
out << " " << *curve;
} else {
out << " (no curve)";
}
}
/**
*
*/
void RopeNode::
write(std::ostream &out, int indent_level) const {
PandaNode::write(out, indent_level);
indent(out, indent_level) << *get_curve() << "\n";
}
/**
* Recomputes the bounding volume. This is normally called automatically, but
* it must occasionally be called explicitly when the curve has changed
* properties outside of this node's knowledge.
*/
void RopeNode::
reset_bound(const NodePath &rel_to) {
Thread *current_thread = Thread::get_current_thread();
int pipeline_stage = current_thread->get_pipeline_stage();
do_recompute_bounds(rel_to, pipeline_stage, current_thread);
mark_internal_bounds_stale(current_thread);
}
/**
* Called when needed to recompute the node's _internal_bound object. Nodes
* that contain anything of substance should redefine this to do the right
* thing.
*/
void RopeNode::
compute_internal_bounds(CPT(BoundingVolume) &internal_bounds,
int &internal_vertices,
int pipeline_stage,
Thread *current_thread) const {
PT(BoundingVolume) bounds =
do_recompute_bounds(NodePath((PandaNode *)this), pipeline_stage,
current_thread);
internal_bounds = bounds;
internal_vertices = 0; // TODO--estimate this better.
}
/**
* Returns the appropriate GeomVertexFormat for rendering, according to the
* user-specified requirements.
*/
CPT(GeomVertexFormat) RopeNode::
get_format(bool support_normals) const {
PT(GeomVertexArrayFormat) array_format = new GeomVertexArrayFormat
(InternalName::get_vertex(), 3, Geom::NT_stdfloat,
Geom::C_point);
if (support_normals && get_normal_mode() == NM_vertex) {
array_format->add_column
(InternalName::get_normal(), 3, Geom::NT_stdfloat,
Geom::C_normal);
}
if (get_use_vertex_color()) {
array_format->add_column
(InternalName::get_color(), 1, Geom::NT_packed_dabc,
Geom::C_color);
}
if (get_uv_mode() != UV_none) {
array_format->add_column
(InternalName::get_texcoord(), 2, Geom::NT_stdfloat,
Geom::C_texcoord);
}
return GeomVertexFormat::register_format(array_format);
}
/**
* Does the actual internal recompute.
*/
PT(BoundingVolume) RopeNode::
do_recompute_bounds(const NodePath &rel_to, int pipeline_stage,
Thread *current_thread) const {
// TODO: fix the bounds so that it properly reflects the indicated pipeline
// stage. At the moment, we cheat and get some of the properties from the
// current pipeline stage, the lazy way.
// First, get ourselves a fresh, empty bounding volume.
PT(BoundingVolume) bound = new BoundingSphere;
NurbsCurveEvaluator *curve = get_curve();
if (curve != nullptr) {
NurbsCurveEvaluator::Vert3Array verts;
get_curve()->get_vertices(verts, rel_to);
if (has_matrix()) {
// And then apply the indicated matrix.
const LMatrix4 &mat = get_matrix();
NurbsCurveEvaluator::Vert3Array::iterator vi;
for (vi = verts.begin(); vi != verts.end(); ++vi) {
(*vi) = LPoint3(*vi) * mat;
}
}
GeometricBoundingVolume *gbv;
DCAST_INTO_R(gbv, bound, bound);
gbv->around(&verts[0], &verts[0] + verts.size());
}
return bound;
}
/**
* Draws the rope in RM_thread mode. This uses a GeomLinestrip to draw the
* rope in the simplest possible method, generally resulting in a one-pixel-
* wide curve.
*
* In this mode, the thickness parameter represents a thickness in pixels, and
* is passed to the linestrip. However, you should be aware the DirectX does
* not support line thickness. This mode does not support per-vertex
* thickness.
*/
void RopeNode::
render_thread(CullTraverser *trav, CullTraverserData &data,
NurbsCurveResult *result) const {
CurveSegments curve_segments;
int num_curve_verts = get_connected_segments(curve_segments, result);
// Now we have stored one or more sequences of vertices down the thread.
// These map directly to primitive vertices.
PT(GeomVertexData) vdata = new GeomVertexData
("rope", get_format(false), Geom::UH_stream);
compute_thread_vertices(vdata, curve_segments, num_curve_verts);
// We use GeomLines instead of GeomLinestrips, since that can more easily be
// rendered directly.
PT(GeomLines) lines = new GeomLines(Geom::UH_stream);
lines->reserve_num_vertices((num_curve_verts - 1) * 2);
for (int vi = 0; vi < num_curve_verts - 1; ++vi) {
lines->add_vertex(vi);
lines->add_vertex(vi + 1);
lines->close_primitive();
}
PT(Geom) geom = new Geom(vdata);
geom->add_primitive(lines);
CPT(RenderAttrib) thick = RenderModeAttrib::make(RenderModeAttrib::M_unchanged, get_thickness());
CPT(RenderState) state = data._state->add_attrib(thick);
if (get_use_vertex_color()) {
state = state->add_attrib(ColorAttrib::make_vertex());
}
CullableObject *object =
new CullableObject(geom, state,
data.get_internal_transform(trav));
trav->get_cull_handler()->record_object(object, trav);
}
/**
* Draws the rope in RM_tape mode. This draws a series of triangle strips
* oriented to be perpendicular to the tube_up vector.
*
* In this mode, thickness is in spatial units, and determines the width of
* the triangle strips.
*/
void RopeNode::
render_tape(CullTraverser *trav, CullTraverserData &data,
NurbsCurveResult *result) const {
CurveSegments curve_segments;
int num_curve_verts = get_connected_segments(curve_segments, result);
// Now we have stored one or more sequences of vertices down the center
// strips. Go back through and calculate the vertices on either side.
PT(GeomVertexData) vdata = new GeomVertexData
("rope", get_format(false), Geom::UH_stream);
compute_billboard_vertices(vdata, -get_tube_up(),
curve_segments, num_curve_verts, result);
// Since this will be a nonindexed primitive, no need to pre-reserve the
// number of vertices.
PT(GeomTristrips) strip = new GeomTristrips(Geom::UH_stream);
CurveSegments::const_iterator si;
for (si = curve_segments.begin(); si != curve_segments.end(); ++si) {
const CurveSegment &segment = (*si);
strip->add_next_vertices(segment.size() * 2);
strip->close_primitive();
}
PT(Geom) geom = new Geom(vdata);
geom->add_primitive(strip);
CPT(RenderState) state = data._state;
if (get_use_vertex_color()) {
state = state->add_attrib(ColorAttrib::make_vertex());
}
CullableObject *object =
new CullableObject(geom, state,
data.get_internal_transform(trav));
trav->get_cull_handler()->record_object(object, trav);
}
/**
* Draws the rope in RM_billboard mode. This draws a series of triangle
* strips oriented to be perpendicular to the camera plane.
*
* In this mode, thickness is in spatial units, and determines the width of
* the triangle strips.
*/
void RopeNode::
render_billboard(CullTraverser *trav, CullTraverserData &data,
NurbsCurveResult *result) const {
const TransformState *net_transform = data.get_net_transform(trav);
const TransformState *camera_transform = trav->get_camera_transform();
CPT(TransformState) rel_transform =
net_transform->invert_compose(camera_transform);
LVector3 camera_vec = LVector3::forward() * rel_transform->get_mat();
CurveSegments curve_segments;
int num_curve_verts = get_connected_segments(curve_segments, result);
// Now we have stored one or more sequences of vertices down the center
// strips. Go back through and calculate the vertices on either side.
PT(GeomVertexData) vdata = new GeomVertexData
("rope", get_format(false), Geom::UH_stream);
compute_billboard_vertices(vdata, camera_vec,
curve_segments, num_curve_verts, result);
// Since this will be a nonindexed primitive, no need to pre-reserve the
// number of vertices.
PT(GeomTristrips) strip = new GeomTristrips(Geom::UH_stream);
CurveSegments::const_iterator si;
for (si = curve_segments.begin(); si != curve_segments.end(); ++si) {
const CurveSegment &segment = (*si);
strip->add_next_vertices(segment.size() * 2);
strip->close_primitive();
}
PT(Geom) geom = new Geom(vdata);
geom->add_primitive(strip);
CPT(RenderState) state = data._state;
if (get_use_vertex_color()) {
state = state->add_attrib(ColorAttrib::make_vertex());
}
CullableObject *object =
new CullableObject(geom, state,
data.get_internal_transform(trav));
trav->get_cull_handler()->record_object(object, trav);
}
/**
* Draws the rope in RM_tube mode. This draws a hollow tube centered around
* the string.
*
* In this mode, thickness is in spatial units, and determines the diameter of
* the tube.
*/
void RopeNode::
render_tube(CullTraverser *trav, CullTraverserData &data,
NurbsCurveResult *result) const {
CurveSegments curve_segments;
int num_curve_verts = get_connected_segments(curve_segments, result);
// Now, we build up a table of vertices, in a series of rings around the
// circumference of the tube.
int num_slices = get_num_slices();
int num_verts_per_slice;
PT(GeomVertexData) vdata = new GeomVertexData
("rope", get_format(true), Geom::UH_stream);
compute_tube_vertices(vdata, num_verts_per_slice,
curve_segments, num_curve_verts, result);
// Finally, go through and build up the index array, to tie all the triangle
// strips together. This is difficult to pre-calculate the number of
// vertices we'll use, so we'll just let it dynamically allocate.
PT(GeomTristrips) strip = new GeomTristrips(Geom::UH_stream);
int vi = 0;
CurveSegments::const_iterator si;
for (si = curve_segments.begin(); si != curve_segments.end(); ++si) {
const CurveSegment &segment = (*si);
for (int s = 0; s < num_slices; ++s) {
int s1 = (s + 1) % num_verts_per_slice;
for (size_t j = 0; j < segment.size(); ++j) {
strip->add_vertex((vi + j) * num_verts_per_slice + s);
strip->add_vertex((vi + j) * num_verts_per_slice + s1);
}
strip->close_primitive();
}
vi += (int)segment.size();
}
PT(Geom) geom = new Geom(vdata);
geom->add_primitive(strip);
CPT(RenderState) state = data._state;
if (get_use_vertex_color()) {
state = state->add_attrib(ColorAttrib::make_vertex());
}
CullableObject *object =
new CullableObject(geom, state,
data.get_internal_transform(trav));
trav->get_cull_handler()->record_object(object, trav);
}
/**
* Evaluates the string of vertices along the curve, and also breaks them up
* into connected segments.
*
* Since the NurbsCurveEvaluator describes the curve as a sequence of
* possibly-connected piecewise continuous segments, this means joining
* together some adjacent segments from the NurbsCurveEvaluator into a single
* CurveSegment, if they happen to be connected (as most will be).
*
* The return value is the total number of points across all segments.
*/
int RopeNode::
get_connected_segments(RopeNode::CurveSegments &curve_segments,
const NurbsCurveResult *result) const {
int num_curve_verts = 0;
int num_verts = get_num_subdiv() + 1;
int num_segments = result->get_num_segments();
bool use_vertex_color = get_use_vertex_color();
bool use_vertex_thickness = get_use_vertex_thickness();
CurveSegment *curve_segment = nullptr;
LPoint3 last_point;
for (int segment = 0; segment < num_segments; ++segment) {
LPoint3 point;
result->eval_segment_point(segment, 0.0f, point);
if (curve_segment == nullptr ||
!point.almost_equal(last_point)) {
// If the first point of this segment is different from the last point
// of the previous segment, end the previous segment and begin a new
// one.
curve_segments.push_back(CurveSegment());
curve_segment = &curve_segments.back();
CurveVertex vtx;
vtx._p = point;
vtx._t = result->get_segment_t(segment, 0.0f);
if (use_vertex_color) {
result->eval_segment_extended_points(segment, 0.0f,
get_vertex_color_dimension(),
&vtx._c[0], 4);
}
if (use_vertex_thickness) {
vtx._thickness =
result->eval_segment_extended_point(segment, 0.0f,
get_vertex_thickness_dimension());
}
curve_segment->push_back(vtx);
++num_curve_verts;
}
// Store all the remaining points in this segment.
for (int i = 1; i < num_verts; ++i) {
PN_stdfloat t = (PN_stdfloat)i / (PN_stdfloat)(num_verts - 1);
CurveVertex vtx;
result->eval_segment_point(segment, t, vtx._p);
vtx._t = result->get_segment_t(segment, t);
if (use_vertex_color) {
result->eval_segment_extended_points(segment, t,
get_vertex_color_dimension(),
&vtx._c[0], 4);
}
if (use_vertex_thickness) {
vtx._thickness =
result->eval_segment_extended_point(segment, t,
get_vertex_thickness_dimension());
}
curve_segment->push_back(vtx);
++num_curve_verts;
last_point = vtx._p;
}
}
return num_curve_verts;
}
/**
* Calculates the vertices for a RM_thread render. This just copies the
* vertices more-or-less directly into the array.
*/
void RopeNode::
compute_thread_vertices(GeomVertexData *vdata,
const RopeNode::CurveSegments &curve_segments,
int num_curve_verts) const {
vdata->set_num_rows(num_curve_verts);
GeomVertexWriter vertex(vdata, InternalName::get_vertex());
GeomVertexWriter color(vdata, InternalName::get_color());
GeomVertexWriter texcoord(vdata, InternalName::get_texcoord());
UVMode uv_mode = get_uv_mode();
PN_stdfloat uv_scale = get_uv_scale();
bool u_dominant = get_uv_direction();
bool use_vertex_color = get_use_vertex_color();
PN_stdfloat dist = 0.0f;
CurveSegments::const_iterator si;
for (si = curve_segments.begin(); si != curve_segments.end(); ++si) {
const CurveSegment &segment = (*si);
for (size_t j = 0; j < segment.size(); ++j) {
vertex.add_data3(segment[j]._p);
if (use_vertex_color) {
color.add_data4(segment[j]._c);
}
PN_stdfloat uv_t = compute_uv_t(dist, uv_mode, uv_scale, segment, j);
if (uv_mode != UV_none) {
if (u_dominant) {
texcoord.add_data2(uv_t, 0.0f);
} else {
texcoord.add_data2(0.0f, uv_t);
}
}
}
}
nassertv(vdata->get_num_rows() == num_curve_verts);
}
/**
* Calculates the vertices for a RM_billboard render. This puts a pair of
* vertices on either side of each computed point in curve_segments.
*/
void RopeNode::
compute_billboard_vertices(GeomVertexData *vdata,
const LVector3 &camera_vec,
const RopeNode::CurveSegments &curve_segments,
int num_curve_verts,
NurbsCurveResult *result) const {
int expected_num_verts = num_curve_verts * 2;
vdata->set_num_rows(expected_num_verts);
GeomVertexWriter vertex(vdata, InternalName::get_vertex());
GeomVertexWriter color(vdata, InternalName::get_color());
GeomVertexWriter texcoord(vdata, InternalName::get_texcoord());
PN_stdfloat thickness = get_thickness();
PN_stdfloat overall_radius = thickness * 0.5f;
PN_stdfloat radius = overall_radius;
UVMode uv_mode = get_uv_mode();
PN_stdfloat uv_scale = get_uv_scale();
bool u_dominant = get_uv_direction();
bool use_vertex_color = get_use_vertex_color();
bool use_vertex_thickness = get_use_vertex_thickness();
PN_stdfloat dist = 0.0f;
CurveSegments::const_iterator si;
for (si = curve_segments.begin(); si != curve_segments.end(); ++si) {
const CurveSegment &segment = (*si);
for (size_t j = 0; j < segment.size(); ++j) {
LVector3 tangent;
compute_tangent(tangent, segment, j, result);
LVector3 norm = cross(tangent, camera_vec);
norm.normalize();
if (use_vertex_thickness) {
radius = overall_radius * segment[j]._thickness;
}
vertex.add_data3(segment[j]._p + norm * radius);
vertex.add_data3(segment[j]._p - norm * radius);
if (use_vertex_color) {
color.add_data4(segment[j]._c);
color.add_data4(segment[j]._c);
}
PN_stdfloat uv_t = compute_uv_t(dist, uv_mode, uv_scale, segment, j);
if (uv_mode != UV_none) {
if (u_dominant) {
texcoord.add_data2(uv_t, 1.0f);
texcoord.add_data2(uv_t, 0.0f);
} else {
texcoord.add_data2(1.0f, uv_t);
texcoord.add_data2(0.0f, uv_t);
}
}
}
}
nassertv(vdata->get_num_rows() == expected_num_verts);
}
/**
* Calculates the vertices for a RM_tube render. This puts a ring of vertices
* around each computed point in curve_segments.
*/
void RopeNode::
compute_tube_vertices(GeomVertexData *vdata,
int &num_verts_per_slice,
const RopeNode::CurveSegments &curve_segments,
int num_curve_verts,
NurbsCurveResult *result) const {
int num_slices = get_num_slices();
num_verts_per_slice = num_slices;
PN_stdfloat thickness = get_thickness();
PN_stdfloat overall_radius = thickness * 0.5f;
PN_stdfloat radius = overall_radius;
UVMode uv_mode = get_uv_mode();
PN_stdfloat uv_scale = get_uv_scale();
bool u_dominant = get_uv_direction();
NormalMode normal_mode = get_normal_mode();
bool use_vertex_color = get_use_vertex_color();
bool use_vertex_thickness = get_use_vertex_thickness();
// If we are generating UV's, we will need to duplicate the vertices along
// the seam so that the UV's go through the whole range of 0..1 instead of
// reflecting in the last polygon before the seam.
if (uv_mode != UV_none) {
++num_verts_per_slice;
}
int expected_num_verts = num_curve_verts * num_verts_per_slice;
vdata->set_num_rows(expected_num_verts);
GeomVertexWriter vertex(vdata, InternalName::get_vertex());
GeomVertexWriter normal(vdata, InternalName::get_normal());
GeomVertexWriter color(vdata, InternalName::get_color());
GeomVertexWriter texcoord(vdata, InternalName::get_texcoord());
LVector3 up = get_tube_up();
PN_stdfloat dist = 0.0f;
CurveSegments::const_iterator si;
for (si = curve_segments.begin(); si != curve_segments.end(); ++si) {
const CurveSegment &segment = (*si);
for (size_t j = 0; j < segment.size(); ++j) {
LVector3 tangent;
compute_tangent(tangent, segment, j, result);
LVector3 norm = cross(tangent, up);
// In case the tangent is linear dependent on the up vector, we might
// get invalid results, so check that
if (IS_NEARLY_ZERO(norm.length_squared())) {
if (IS_NEARLY_ZERO(tangent.get_y()) && IS_NEARLY_ZERO(tangent.get_z())) {
// Vector is linear dependent on (1, 0, 0), use (0, 1, 0) as base
norm = cross(tangent, LVector3(0, 1, 0));
} else {
norm = cross(tangent, LVector3(1, 0, 0));
}
}
norm.normalize();
up = cross(norm, tangent);
LMatrix3 rotate = LMatrix3::rotate_mat(360.0f / (PN_stdfloat)num_slices,
tangent);
PN_stdfloat uv_t = compute_uv_t(dist, uv_mode, uv_scale, segment, j);
for (int s = 0; s < num_verts_per_slice; ++s) {
if (use_vertex_thickness) {
radius = overall_radius * segment[j]._thickness;
}
vertex.add_data3(segment[j]._p + norm * radius);
if (normal_mode == NM_vertex) {
normal.add_data3(norm);
}
if (use_vertex_color) {
color.add_data4(segment[j]._c);
}
norm = norm * rotate;
if (uv_mode != UV_none) {
PN_stdfloat uv_s = (PN_stdfloat)s / (PN_stdfloat)num_slices;
if (u_dominant) {
texcoord.add_data2(uv_t, uv_s);
} else {
texcoord.add_data2(uv_s, uv_t);
}
}
}
}
}
nassertv(vdata->get_num_rows() == expected_num_verts);
}
/**
* Computes the tangent to the curve at the indicated point in the segment.
*/
void RopeNode::
compute_tangent(LVector3 &tangent, const RopeNode::CurveSegment &segment,
size_t j, NurbsCurveResult *result) {
// First, try to evaluate the tangent at the curve. This gives better
// results at the ends at the endpoints where the tangent does not go to
// zero.
/*
Actually, on second thought this looks terrible.
if (result->eval_tangent(segment[j]._t, tangent)) {
if (!tangent.almost_equal(LVector3::zero())) {
return;
}
}
*/
// If that failed (or produced a zero tangent), then derive the tangent from
// the neighboring points instead.
if (j == 0) {
tangent = segment[j + 1]._p - segment[j]._p;
} else if (j == segment.size() - 1) {
tangent = segment[j]._p - segment[j - 1]._p;
} else {
tangent = segment[j + 1]._p - segment[j - 1]._p;
}
// Avoid empty tangents, these lead to crashes. Instead, use an arbitrary
// tangent.
if (IS_NEARLY_ZERO(tangent.length_squared())) {
tangent.set(0, 0, 1);
}
}
/**
* Computes the texture coordinate along the curve for the indicated point in
* the segment.
*/
PN_stdfloat RopeNode::
compute_uv_t(PN_stdfloat &dist, const RopeNode::UVMode &uv_mode,
PN_stdfloat uv_scale, const RopeNode::CurveSegment &segment,
size_t j) {
switch (uv_mode) {
case UV_none:
return 0.0f;
case UV_parametric:
return segment[j]._t * uv_scale;
case UV_distance:
if (j != 0) {
LVector3 vec = segment[j]._p - segment[j - 1]._p;
dist += vec.length();
}
return dist * uv_scale;
case UV_distance2:
if (j != 0) {
LVector3 vec = segment[j]._p - segment[j - 1]._p;
dist += vec.length_squared();
}
return dist * uv_scale;
}
return 0.0f;
}
/**
* Tells the BamReader how to create objects of type RopeNode.
*/
void RopeNode::
register_with_read_factory() {
BamReader::get_factory()->register_factory(get_class_type(), make_from_bam);
}
/**
* Writes the contents of this object to the datagram for shipping out to a
* Bam file.
*/
void RopeNode::
write_datagram(BamWriter *manager, Datagram &dg) {
PandaNode::write_datagram(manager, dg);
manager->write_cdata(dg, _cycler);
}
/**
* This function is called by the BamReader's factory when a new object of
* type RopeNode is encountered in the Bam file. It should create the
* RopeNode and extract its information from the file.
*/
TypedWritable *RopeNode::
make_from_bam(const FactoryParams ¶ms) {
RopeNode *node = new RopeNode("");
DatagramIterator scan;
BamReader *manager;
parse_params(params, scan, manager);
node->fillin(scan, manager);
return node;
}
/**
* This internal function is called by make_from_bam to read in all of the
* relevant data from the BamFile for the new RopeNode.
*/
void RopeNode::
fillin(DatagramIterator &scan, BamReader *manager) {
PandaNode::fillin(scan, manager);
manager->read_cdata(scan, _cycler);
}
|
; Commodore 64 Cynthcart LOADER
; by Paul Slocum
;------------------------
; TEXT EDITOR TAB=3
;------------------------
;------------------------
;------------------------
; TODO
;------------------------
; - LFO -> Pulse Width and Volume and Filter
;--------------------------
;--------------------------
;#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#
;# MEMORY MAP
;#
;# $0800-$3800 Program and data
;# $7000-$7200 Variables and buffers (512 bytes)
;# $7F00-$7FFF MIDI ring buffer
;#
;#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#=#
;/\ \/ /\ \/ /\ \/ /\ \/ /\ \/ /\ \/ /\ \/ /\ \/ /\ \/ /\ \/ /\ \/ /\ \/
processor 6502
; Image run mode:
CART equ 0 ; run at $8000 off cartridge ROM
DISK equ 1 ; run at $2047, include BASIC sys command
RAM equ 2 ; run at $8000 in RAM from PRG
;**********************************************************
;**********************************************************
; PROGRAM CONFIGURATION SWITCHES
;**********************************************************
;**********************************************************
;MODE equ DISK ; DISK mode is for testing
;MODE equ CART
MODE equ RAM
;**********************************************************
;**********************************************************
;**********************************************************
; *********************************************
; START OF PROGRAM IN MEMORY
; *********************************************
;==================================================
; straight cart ROM
IF MODE=CART
BASEADDR equ $8000
org BASEADDR
word Startup
word Startup
; 5 byte cartridge startup code
byte $C3, $C2, $CD, $38, $30
ENDIF
;==================================================
; load from disk as PRG with auto-run
IF MODE=DISK
BASEADDR equ 2047 ; 2047 = $7FF
org BASEADDR ; the beginning of the BASIC program area
; disk load location
byte $01,$08
; BASIC program to call the cynthcart machine code...
; 10 SYS 2061
byte $0b,$08, $0a,$00,$9e,$32, $30,$36,$31,$00, $00,$00
; next effective address after this is 2061 / $80D
ENDIF
;==================================================
; load from disk as PRG with auto-run
IF MODE=RAM
BASEADDR equ $8000 ;
org BASEADDR-2 ; the beginning of the BASIC program area
; disk load location
byte $00,$80
ENDIF
;---------------------------------------
; variables and constants here
;---------------------------------------
; *********************************************
; Start of program
; *********************************************
Startup:
IF MODE=CART
; System Startup Stuff
; (not needed if starting from disk)
sei
jsr $FF84 ; initialize I/O devices
jsr $FF87 ; initalise memory pointers
jsr $FF8A ; restore I/O vectors
jsr $FF81 ; initalise screen and keyboard
cli
ENDIF
lda #0
sta 53281
sta 53280
lda #1
sta 1064
;=- =- =- =- =- =- =- =- =- =- =- =- =- =-
;=- =- =- =- =- =- =- =- =- =- =- =- =- =-
;=- =- =- =- =- =- =- =- =- =- =- =- =- =-
;=- =- =- =- =- =- =- =- =- =- =- =- =- =-
;=- =- =- =- =- =- =- =- =- =- =- =- =- =-
;=- =- =- =- =- =- =- =- =- =- =- =- =- =-
; switch to lowercase mode
lda #23
sta $d018
lda #0 ; DEBUG put character on screen
sta 1024
lda #1 ; DEBUG put character on screen
sta 1025
;lda #2 ; DEBUG put character on screen
;sta 1026
jmp 2061 ; JMP to start of built-in decomopression routine
ldx #>compressedData ;H
ldy #<compressedData ;L
iny
iny
sty 1028
jsr decomp
bcc good
bad:
lda #2 ; 'b'
sta 1030
jmp stop
good:
lda #7 ; 'g'
sta 1028
;jmp $5000
; ORG $c000
; Call with X = HI of packed data, Y = LO of packed data
; Returns exec address in X = HI and Y = LO
; Carry will be set for error, cleared for OK
; Lock cpu (DEBUG)
stop:
jmp stop
compressedData:
;incbin "cynthcart152_comp.prg"
incbin "cynthcart152stand.cmp"
;incbin "eprom.cmp" ; DEBUG!!
decompressor:
include "sa_uncrunch.asm"
;IF MODE=KERNEL_OBSOLETE
;org $bfff
;byte 0
;ENDIF
|
// Copyright 2013 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "src/api.h"
#include "src/arm64/assembler-arm64-inl.h"
#include "src/arm64/macro-assembler-arm64-inl.h"
#include "src/codegen.h"
#include "src/deoptimizer.h"
#include "src/frame-constants.h"
#include "src/register-configuration.h"
#include "src/safepoint-table.h"
namespace v8 {
namespace internal {
int Deoptimizer::patch_size() {
// Size of the code used to patch lazy bailout points.
// Patching is done by Deoptimizer::DeoptimizeFunction.
return 4 * kInstructionSize;
}
void Deoptimizer::EnsureRelocSpaceForLazyDeoptimization(Handle<Code> code) {
// Empty because there is no need for relocation information for the code
// patching in Deoptimizer::PatchCodeForDeoptimization below.
}
void Deoptimizer::PatchCodeForDeoptimization(Isolate* isolate, Code* code) {
Address code_start_address = code->instruction_start();
// Invalidate the relocation information, as it will become invalid by the
// code patching below, and is not needed any more.
code->InvalidateRelocation();
// Fail hard and early if we enter this code object again.
byte* pointer = code->FindCodeAgeSequence();
if (pointer != NULL) {
pointer += kNoCodeAgeSequenceLength;
} else {
pointer = code->instruction_start();
}
{
PatchingAssembler patcher(Assembler::IsolateData(isolate), pointer, 1);
patcher.brk(0);
}
DeoptimizationInputData* data =
DeoptimizationInputData::cast(code->deoptimization_data());
int osr_offset = data->OsrPcOffset()->value();
if (osr_offset > 0) {
PatchingAssembler patcher(Assembler::IsolateData(isolate),
code_start_address + osr_offset, 1);
patcher.brk(0);
}
DeoptimizationInputData* deopt_data =
DeoptimizationInputData::cast(code->deoptimization_data());
#ifdef DEBUG
Address prev_call_address = NULL;
#endif
// For each LLazyBailout instruction insert a call to the corresponding
// deoptimization entry.
for (int i = 0; i < deopt_data->DeoptCount(); i++) {
if (deopt_data->Pc(i)->value() == -1) continue;
Address call_address = code_start_address + deopt_data->Pc(i)->value();
Address deopt_entry = GetDeoptimizationEntry(isolate, i, LAZY);
PatchingAssembler patcher(isolate, call_address,
patch_size() / kInstructionSize);
patcher.ldr_pcrel(ip0, (2 * kInstructionSize) >> kLoadLiteralScaleLog2);
patcher.blr(ip0);
patcher.dc64(reinterpret_cast<intptr_t>(deopt_entry));
DCHECK((prev_call_address == NULL) ||
(call_address >= prev_call_address + patch_size()));
DCHECK(call_address + patch_size() <= code->instruction_end());
#ifdef DEBUG
prev_call_address = call_address;
#endif
}
}
#define __ masm()->
void Deoptimizer::TableEntryGenerator::Generate() {
GeneratePrologue();
// TODO(all): This code needs to be revisited. We probably only need to save
// caller-saved registers here. Callee-saved registers can be stored directly
// in the input frame.
// Save all allocatable double registers.
CPURegList saved_double_registers(
CPURegister::kVRegister, kDRegSizeInBits,
RegisterConfiguration::Default()->allocatable_double_codes_mask());
__ PushCPURegList(saved_double_registers);
// Save all allocatable float registers.
CPURegList saved_float_registers(
CPURegister::kVRegister, kSRegSizeInBits,
RegisterConfiguration::Default()->allocatable_float_codes_mask());
__ PushCPURegList(saved_float_registers);
// We save all the registers expcept jssp, sp and lr.
CPURegList saved_registers(CPURegister::kRegister, kXRegSizeInBits, 0, 27);
saved_registers.Combine(fp);
__ PushCPURegList(saved_registers);
__ Mov(x3, Operand(ExternalReference(IsolateAddressId::kCEntryFPAddress,
isolate())));
__ Str(fp, MemOperand(x3));
const int kSavedRegistersAreaSize =
(saved_registers.Count() * kXRegSize) +
(saved_double_registers.Count() * kDRegSize) +
(saved_float_registers.Count() * kSRegSize);
// Floating point registers are saved on the stack above core registers.
const int kFloatRegistersOffset = saved_registers.Count() * kXRegSize;
const int kDoubleRegistersOffset =
kFloatRegistersOffset + saved_float_registers.Count() * kSRegSize;
// Get the bailout id from the stack.
Register bailout_id = x2;
__ Peek(bailout_id, kSavedRegistersAreaSize);
Register code_object = x3;
Register fp_to_sp = x4;
// Get the address of the location in the code object. This is the return
// address for lazy deoptimization.
__ Mov(code_object, lr);
// Compute the fp-to-sp delta, and correct one word for bailout id.
__ Add(fp_to_sp, __ StackPointer(),
kSavedRegistersAreaSize + (1 * kPointerSize));
__ Sub(fp_to_sp, fp, fp_to_sp);
// Allocate a new deoptimizer object.
__ Mov(x0, 0);
Label context_check;
__ Ldr(x1, MemOperand(fp, CommonFrameConstants::kContextOrFrameTypeOffset));
__ JumpIfSmi(x1, &context_check);
__ Ldr(x0, MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset));
__ bind(&context_check);
__ Mov(x1, type());
// Following arguments are already loaded:
// - x2: bailout id
// - x3: code object address
// - x4: fp-to-sp delta
__ Mov(x5, ExternalReference::isolate_address(isolate()));
{
// Call Deoptimizer::New().
AllowExternalCallThatCantCauseGC scope(masm());
__ CallCFunction(ExternalReference::new_deoptimizer_function(isolate()), 6);
}
// Preserve "deoptimizer" object in register x0.
Register deoptimizer = x0;
// Get the input frame descriptor pointer.
__ Ldr(x1, MemOperand(deoptimizer, Deoptimizer::input_offset()));
// Copy core registers into the input frame.
CPURegList copy_to_input = saved_registers;
for (int i = 0; i < saved_registers.Count(); i++) {
__ Peek(x2, i * kPointerSize);
CPURegister current_reg = copy_to_input.PopLowestIndex();
int offset = (current_reg.code() * kPointerSize) +
FrameDescription::registers_offset();
__ Str(x2, MemOperand(x1, offset));
}
// Copy double registers to the input frame.
CPURegList copy_double_to_input = saved_double_registers;
for (int i = 0; i < saved_double_registers.Count(); i++) {
int src_offset = kDoubleRegistersOffset + (i * kDoubleSize);
__ Peek(x2, src_offset);
CPURegister reg = copy_double_to_input.PopLowestIndex();
int dst_offset = FrameDescription::double_registers_offset() +
(reg.code() * kDoubleSize);
__ Str(x2, MemOperand(x1, dst_offset));
}
// Copy float registers to the input frame.
CPURegList copy_float_to_input = saved_float_registers;
for (int i = 0; i < saved_float_registers.Count(); i++) {
int src_offset = kFloatRegistersOffset + (i * kFloatSize);
__ Peek(w2, src_offset);
CPURegister reg = copy_float_to_input.PopLowestIndex();
int dst_offset =
FrameDescription::float_registers_offset() + (reg.code() * kFloatSize);
__ Str(w2, MemOperand(x1, dst_offset));
}
// Remove the bailout id and the saved registers from the stack.
__ Drop(1 + (kSavedRegistersAreaSize / kXRegSize));
// Compute a pointer to the unwinding limit in register x2; that is
// the first stack slot not part of the input frame.
Register unwind_limit = x2;
__ Ldr(unwind_limit, MemOperand(x1, FrameDescription::frame_size_offset()));
__ Add(unwind_limit, unwind_limit, __ StackPointer());
// Unwind the stack down to - but not including - the unwinding
// limit and copy the contents of the activation frame to the input
// frame description.
__ Add(x3, x1, FrameDescription::frame_content_offset());
Label pop_loop;
Label pop_loop_header;
__ B(&pop_loop_header);
__ Bind(&pop_loop);
__ Pop(x4);
__ Str(x4, MemOperand(x3, kPointerSize, PostIndex));
__ Bind(&pop_loop_header);
__ Cmp(unwind_limit, __ StackPointer());
__ B(ne, &pop_loop);
// Compute the output frame in the deoptimizer.
__ Push(x0); // Preserve deoptimizer object across call.
{
// Call Deoptimizer::ComputeOutputFrames().
AllowExternalCallThatCantCauseGC scope(masm());
__ CallCFunction(
ExternalReference::compute_output_frames_function(isolate()), 1);
}
__ Pop(x4); // Restore deoptimizer object (class Deoptimizer).
__ Ldr(__ StackPointer(),
MemOperand(x4, Deoptimizer::caller_frame_top_offset()));
// Replace the current (input) frame with the output frames.
Label outer_push_loop, inner_push_loop,
outer_loop_header, inner_loop_header;
__ Ldrsw(x1, MemOperand(x4, Deoptimizer::output_count_offset()));
__ Ldr(x0, MemOperand(x4, Deoptimizer::output_offset()));
__ Add(x1, x0, Operand(x1, LSL, kPointerSizeLog2));
__ B(&outer_loop_header);
__ Bind(&outer_push_loop);
Register current_frame = x2;
__ Ldr(current_frame, MemOperand(x0, 0));
__ Ldr(x3, MemOperand(current_frame, FrameDescription::frame_size_offset()));
__ B(&inner_loop_header);
__ Bind(&inner_push_loop);
__ Sub(x3, x3, kPointerSize);
__ Add(x6, current_frame, x3);
__ Ldr(x7, MemOperand(x6, FrameDescription::frame_content_offset()));
__ Push(x7);
__ Bind(&inner_loop_header);
__ Cbnz(x3, &inner_push_loop);
__ Add(x0, x0, kPointerSize);
__ Bind(&outer_loop_header);
__ Cmp(x0, x1);
__ B(lt, &outer_push_loop);
__ Ldr(x1, MemOperand(x4, Deoptimizer::input_offset()));
DCHECK(!saved_double_registers.IncludesAliasOf(crankshaft_fp_scratch) &&
!saved_double_registers.IncludesAliasOf(fp_zero) &&
!saved_double_registers.IncludesAliasOf(fp_scratch));
while (!saved_double_registers.IsEmpty()) {
const CPURegister reg = saved_double_registers.PopLowestIndex();
int src_offset = FrameDescription::double_registers_offset() +
(reg.code() * kDoubleSize);
__ Ldr(reg, MemOperand(x1, src_offset));
}
// Push state from the last output frame.
__ Ldr(x6, MemOperand(current_frame, FrameDescription::state_offset()));
__ Push(x6);
// TODO(all): ARM copies a lot (if not all) of the last output frame onto the
// stack, then pops it all into registers. Here, we try to load it directly
// into the relevant registers. Is this correct? If so, we should improve the
// ARM code.
// TODO(all): This code needs to be revisited, We probably don't need to
// restore all the registers as fullcodegen does not keep live values in
// registers (note that at least fp must be restored though).
// Restore registers from the last output frame.
// Note that lr is not in the list of saved_registers and will be restored
// later. We can use it to hold the address of last output frame while
// reloading the other registers.
DCHECK(!saved_registers.IncludesAliasOf(lr));
Register last_output_frame = lr;
__ Mov(last_output_frame, current_frame);
// We don't need to restore x7 as it will be clobbered later to hold the
// continuation address.
Register continuation = x7;
saved_registers.Remove(continuation);
while (!saved_registers.IsEmpty()) {
// TODO(all): Look for opportunities to optimize this by using ldp.
CPURegister current_reg = saved_registers.PopLowestIndex();
int offset = (current_reg.code() * kPointerSize) +
FrameDescription::registers_offset();
__ Ldr(current_reg, MemOperand(last_output_frame, offset));
}
__ Ldr(continuation, MemOperand(last_output_frame,
FrameDescription::continuation_offset()));
__ Ldr(lr, MemOperand(last_output_frame, FrameDescription::pc_offset()));
__ InitializeRootRegister();
__ Br(continuation);
}
// Size of an entry of the second level deopt table.
// This is the code size generated by GeneratePrologue for one entry.
const int Deoptimizer::table_entry_size_ = 2 * kInstructionSize;
void Deoptimizer::TableEntryGenerator::GeneratePrologue() {
UseScratchRegisterScope temps(masm());
Register entry_id = temps.AcquireX();
// Create a sequence of deoptimization entries.
// Note that registers are still live when jumping to an entry.
Label done;
{
InstructionAccurateScope scope(masm());
// The number of entry will never exceed kMaxNumberOfEntries.
// As long as kMaxNumberOfEntries is a valid 16 bits immediate you can use
// a movz instruction to load the entry id.
DCHECK(is_uint16(Deoptimizer::kMaxNumberOfEntries));
for (int i = 0; i < count(); i++) {
int start = masm()->pc_offset();
USE(start);
__ movz(entry_id, i);
__ b(&done);
DCHECK(masm()->pc_offset() - start == table_entry_size_);
}
}
__ Bind(&done);
__ Push(entry_id);
}
void FrameDescription::SetCallerPc(unsigned offset, intptr_t value) {
SetFrameSlot(offset, value);
}
void FrameDescription::SetCallerFp(unsigned offset, intptr_t value) {
SetFrameSlot(offset, value);
}
void FrameDescription::SetCallerConstantPool(unsigned offset, intptr_t value) {
// No embedded constant pool support.
UNREACHABLE();
}
#undef __
} // namespace internal
} // namespace v8
|
swordgfx:
;incbin swords.gfx
skip #$1000
shieldgfx:
;incbin shields.gfx
skip #$C00
CopySword:
{
PHB : PHK : PLB
PHP ;push processor byte
REP #$30 ; set everything to 16-bit
LDY #$0000
LDA $7EF359 : AND.w #$00FF : ASL : TAX ;Load Sword Value
LDA.w .sword_positon_gfx, X : TAX
.loop_copy
LDA swordgfx, X : PHX : TYX : STA $7E9000, X : PLX
LDA swordgfx+#$200, X : PHX : TYX : STA $7E9180, X : PLX
INX : INX : INY : INY
CPY #$0180 : BCC .loop_copy
PLP ;pull processor byte
PLB
RTL
.sword_positon_gfx
dw #$0000, #$0000, #$0400, #$0800, #$0C00 ; swords position in gfx file
}
CopyShield:
{
PHB : PHK : PLB
PHP ;push processor byte
REP #$30 ; set everything to 16-bit
LDY #$0300
LDA $7EF35A : AND.w #$00FF : ASL : TAX ;Load Shield value
LDA.w .shield_positon_gfx, X : TAX
.loop_copy
LDA shieldgfx, X : PHX : TYX : STA $7E9000, X : PLX
LDA shieldgfx+#$200, X : PHX : TYX : STA $7E90C0, X : PLX
INX : INX : INY : INY
CPY #$03C0 : BCC .loop_copy
PLP ;pull processor byte
PLB
RTL
.shield_positon_gfx
dw #$0000,#$0000, #$0400, #$0800
}
|
// Copyright (c) 2007-2016 Erick Jung
//
// This code is distributed under the terms and conditions of the MIT license.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
inline void Transformation::setTranslation(const math::Vector3f &translate)
{
_translate = translate;
}
inline const math::Vector3f &Transformation::getTranslation()
{
return _translate;
}
inline void Transformation::setRotation(float rotateAngle, const math::Vector3f &rotate)
{
_rotateAngle = rotateAngle;
_rotate = rotate;
}
inline void Transformation::getRotation(float &rotateAngle, math::Vector3f &rotate)
{
rotateAngle = _rotateAngle;
rotate = _rotate;
}
inline void Transformation::setScale(math::Vector3f scale)
{
_scale = scale;
}
inline const math::Vector3f &Transformation::getScale()
{
return _scale;
}
inline void Transformation::setTarget(const math::Vector3f &target)
{
_target = target;
}
inline const math::Vector3f &Transformation::getTarget()
{
return _target;
}
|
SECTION code_fp_math48
PUBLIC ___fs2uint
EXTERN cm48_sdcciyp_ds2uint
defc ___fs2uint = cm48_sdcciyp_ds2uint
|
; A215500: a(n) = ((sqrt(5) + 3)^n + (-sqrt(5) -1)^n + (-sqrt(5) + 3)^n + (sqrt(5) - 1)^n) / 2^n.
; Submitted by Jon Maiga
; 4,2,10,14,54,112,340,814,2254,5702,15250,39404,104004,270922,711490,1859134,4873054,12748472,33391060,87394454,228841254,599050102,1568437210,4106054164,10750060804,28143585362,73681573690,192899714414,505019869254,1322156172352,3461454668500,9062198091454,23725155368254,62113242509222,162614613425890,425730530997884,1114577087604804,2918000557008922,7639424866266610,20000273584138654,52361396626646254,137083915097650952,358890350604952660,939587133580411814,2459871055211724054
lpb $0
sub $0,1
add $4,1
add $4,$1
add $1,$4
add $4,1
max $5,$1
add $5,$2
mov $2,$3
add $2,$4
sub $5,$4
sub $5,$3
mov $3,$5
lpe
mov $0,$3
add $0,2
mul $0,2
|
; A023446: n-4.
; -4,-3,-2,-1,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54
sub $0,4
mul $0,120259084288
mov $1,$0
div $1,120259084288
|
SECTION code_clib
PUBLIC generic_console_xypos
EXTERN __laser500_mode
defc DISPLAY = 0xf800 - 0x8000
;
; Entry: b = character y
; c = character x
; Exit:
; hl = 80 column position
; bc = extra step to get to 40 columns
; Preserves: af
generic_console_xypos:
push af
ld a,b ; Modulus 8
and 7
ld h,a ;*256
ld l,0
srl b ;y/ 8
srl b
srl b
ld de,80
inc b
generic_console_xypos_1:
add hl,de
djnz generic_console_xypos_1
and a ;We went one row too far
sbc hl,de
generic_console_xypos_3:
add hl,bc ;hl now points to address in display
ld de,DISPLAY
ld a,(__laser500_mode)
cp 2
jr nz,not_hires
ld de,$4000
not_hires:
add hl,de
pop af
ret
|
; A027626: Denominator of n*(n+5)/((n+2)*(n+3)).
; 1,2,10,5,7,28,12,15,55,22,26,91,35,40,136,51,57,190,70,77,253,92,100,325,117,126,406,145,155,496,176,187,595,210,222,703,247,260,820,287,301,946,330,345,1081,376,392,1225,425,442,1378,477,495,1540,532,551,1711,590,610,1891,651,672,2080,715,737,2278,782,805,2485,852,876,2701,925,950,2926,1001,1027,3160,1080,1107,3403,1162,1190,3655,1247,1276,3916,1335,1365,4186,1426,1457,4465,1520,1552,4753,1617,1650,5050,1717
add $0,3
bin $0,2
dif $0,3
|
.global s_prepare_buffers
s_prepare_buffers:
push %r10
push %r13
push %r15
push %r9
push %rax
push %rbx
push %rcx
push %rdi
push %rsi
lea addresses_normal_ht+0x916f, %r9
nop
nop
nop
xor %r15, %r15
movw $0x6162, (%r9)
nop
nop
nop
nop
nop
sub %rax, %rax
lea addresses_WT_ht+0xc30f, %rsi
sub %rbx, %rbx
movb $0x61, (%rsi)
nop
nop
add %r15, %r15
lea addresses_WC_ht+0x1449e, %r15
nop
nop
nop
nop
and $23425, %r10
mov (%r15), %r9
nop
nop
nop
nop
nop
add $3068, %r10
lea addresses_WC_ht+0x4a6f, %r15
nop
sub %r10, %r10
mov (%r15), %rbx
nop
and %rax, %rax
lea addresses_WC_ht+0x19d5f, %rbx
nop
inc %rax
mov (%rbx), %r13w
nop
nop
nop
nop
add %rbx, %rbx
lea addresses_UC_ht+0x858f, %rsi
lea addresses_normal_ht+0x11c57, %rdi
nop
nop
nop
xor %r10, %r10
mov $51, %rcx
rep movsl
nop
add $47888, %rdi
lea addresses_UC_ht+0x800f, %r10
nop
and %rax, %rax
movb (%r10), %cl
nop
nop
add %r15, %r15
lea addresses_UC_ht+0xd80f, %rcx
nop
and %r15, %r15
movw $0x6162, (%rcx)
nop
nop
nop
nop
and $14024, %rcx
lea addresses_WC_ht+0x64f, %r10
sub %rcx, %rcx
movb $0x61, (%r10)
nop
nop
inc %r10
lea addresses_WT_ht+0x1140f, %r13
nop
nop
cmp $2232, %r15
mov (%r13), %eax
sub %r10, %r10
lea addresses_WC_ht+0x70f, %r9
nop
nop
cmp %r10, %r10
mov (%r9), %r13w
nop
nop
nop
nop
nop
and $34254, %rdi
lea addresses_UC_ht+0x298f, %rdi
clflush (%rdi)
nop
nop
nop
and $55592, %rbx
movw $0x6162, (%rdi)
nop
nop
nop
nop
nop
sub $34929, %rcx
pop %rsi
pop %rdi
pop %rcx
pop %rbx
pop %rax
pop %r9
pop %r15
pop %r13
pop %r10
ret
.global s_faulty_load
s_faulty_load:
push %r11
push %r8
push %rax
push %rcx
push %rsi
// Faulty Load
lea addresses_WC+0xa00f, %rsi
nop
nop
add $38675, %r8
movb (%rsi), %al
lea oracles, %rcx
and $0xff, %rax
shlq $12, %rax
mov (%rcx,%rax,1), %rax
pop %rsi
pop %rcx
pop %rax
pop %r8
pop %r11
ret
/*
<gen_faulty_load>
[REF]
{'OP': 'LOAD', 'src': {'type': 'addresses_WC', 'size': 16, 'AVXalign': False, 'NT': False, 'congruent': 0, 'same': False}}
[Faulty Load]
{'OP': 'LOAD', 'src': {'type': 'addresses_WC', 'size': 1, 'AVXalign': False, 'NT': False, 'congruent': 0, 'same': True}}
<gen_prepare_buffer>
{'OP': 'STOR', 'dst': {'type': 'addresses_normal_ht', 'size': 2, 'AVXalign': True, 'NT': False, 'congruent': 3, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_WT_ht', 'size': 1, 'AVXalign': False, 'NT': False, 'congruent': 4, 'same': False}}
{'OP': 'LOAD', 'src': {'type': 'addresses_WC_ht', 'size': 8, 'AVXalign': False, 'NT': False, 'congruent': 0, 'same': False}}
{'OP': 'LOAD', 'src': {'type': 'addresses_WC_ht', 'size': 8, 'AVXalign': False, 'NT': False, 'congruent': 4, 'same': False}}
{'OP': 'LOAD', 'src': {'type': 'addresses_WC_ht', 'size': 2, 'AVXalign': False, 'NT': False, 'congruent': 4, 'same': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_UC_ht', 'congruent': 6, 'same': False}, 'dst': {'type': 'addresses_normal_ht', 'congruent': 3, 'same': True}}
{'OP': 'LOAD', 'src': {'type': 'addresses_UC_ht', 'size': 1, 'AVXalign': False, 'NT': False, 'congruent': 11, 'same': True}}
{'OP': 'STOR', 'dst': {'type': 'addresses_UC_ht', 'size': 2, 'AVXalign': False, 'NT': False, 'congruent': 11, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_WC_ht', 'size': 1, 'AVXalign': True, 'NT': False, 'congruent': 2, 'same': True}}
{'OP': 'LOAD', 'src': {'type': 'addresses_WT_ht', 'size': 4, 'AVXalign': False, 'NT': True, 'congruent': 7, 'same': False}}
{'OP': 'LOAD', 'src': {'type': 'addresses_WC_ht', 'size': 2, 'AVXalign': False, 'NT': True, 'congruent': 5, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_UC_ht', 'size': 2, 'AVXalign': False, 'NT': False, 'congruent': 7, 'same': False}}
{'38': 21829}
38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38
*/
|
.global s_prepare_buffers
s_prepare_buffers:
push %r12
push %r13
push %r14
push %rbx
push %rcx
push %rdi
push %rdx
push %rsi
lea addresses_A_ht+0x1ba5e, %rcx
and $35801, %r14
movb (%rcx), %dl
nop
and $34629, %rdi
lea addresses_WC_ht+0x10181, %rdi
nop
nop
xor $21429, %r12
and $0xffffffffffffffc0, %rdi
vmovaps (%rdi), %ymm3
vextracti128 $0, %ymm3, %xmm3
vpextrq $0, %xmm3, %rbx
nop
nop
and %r12, %r12
lea addresses_WC_ht+0x9e5a, %rcx
nop
nop
nop
nop
and %rbx, %rbx
mov $0x6162636465666768, %rdx
movq %rdx, %xmm0
and $0xffffffffffffffc0, %rcx
movntdq %xmm0, (%rcx)
nop
nop
nop
nop
nop
dec %r14
lea addresses_A_ht+0x1d81, %rsi
lea addresses_WT_ht+0x19f81, %rdi
nop
nop
nop
inc %r12
mov $71, %rcx
rep movsq
sub $58417, %rcx
lea addresses_UC_ht+0x9969, %r14
nop
nop
nop
nop
inc %rbx
movb (%r14), %dl
nop
nop
nop
inc %rdx
lea addresses_WT_ht+0xe581, %rbx
nop
nop
nop
nop
sub %rsi, %rsi
movb (%rbx), %r12b
add $54828, %r14
lea addresses_WC_ht+0x3f61, %rsi
lea addresses_WC_ht+0x1cf01, %rdi
nop
nop
cmp $7233, %r13
mov $79, %rcx
rep movsb
nop
nop
cmp %r12, %r12
lea addresses_normal_ht+0x181, %rsi
lea addresses_WT_ht+0xeb41, %rdi
clflush (%rsi)
nop
nop
add %rdx, %rdx
mov $9, %rcx
rep movsl
nop
sub $64642, %rsi
lea addresses_WT_ht+0x9f81, %r12
cmp %rbx, %rbx
mov (%r12), %r13
sub %rdx, %rdx
lea addresses_WT_ht+0x101a1, %rsi
dec %rbx
movl $0x61626364, (%rsi)
nop
nop
nop
inc %r13
lea addresses_normal_ht+0x3941, %rsi
lea addresses_UC_ht+0x169d1, %rdi
nop
nop
nop
cmp %rbx, %rbx
mov $86, %rcx
rep movsw
and %r12, %r12
lea addresses_WT_ht+0x13181, %rdx
nop
nop
nop
nop
sub $49090, %rcx
mov (%rdx), %r13d
nop
nop
nop
xor %rcx, %rcx
pop %rsi
pop %rdx
pop %rdi
pop %rcx
pop %rbx
pop %r14
pop %r13
pop %r12
ret
.global s_faulty_load
s_faulty_load:
push %r10
push %r11
push %r13
push %r14
push %rax
push %rdi
push %rdx
// Store
lea addresses_PSE+0xdd81, %rdx
nop
nop
nop
cmp $6101, %rdi
mov $0x5152535455565758, %r14
movq %r14, %xmm5
vmovups %ymm5, (%rdx)
nop
add %rdi, %rdi
// Store
lea addresses_PSE+0x9cbd, %r14
clflush (%r14)
nop
nop
nop
nop
and %rax, %rax
movl $0x51525354, (%r14)
nop
nop
nop
nop
nop
inc %r10
// Store
lea addresses_WC+0x2b81, %rax
nop
nop
nop
and %r11, %r11
movl $0x51525354, (%rax)
nop
nop
nop
nop
cmp %r13, %r13
// Faulty Load
lea addresses_A+0x5581, %rax
nop
nop
nop
nop
nop
dec %rdx
movups (%rax), %xmm3
vpextrq $1, %xmm3, %rdi
lea oracles, %rax
and $0xff, %rdi
shlq $12, %rdi
mov (%rax,%rdi,1), %rdi
pop %rdx
pop %rdi
pop %rax
pop %r14
pop %r13
pop %r11
pop %r10
ret
/*
<gen_faulty_load>
[REF]
{'OP': 'LOAD', 'src': {'same': False, 'type': 'addresses_A', 'NT': False, 'AVXalign': False, 'size': 16, 'congruent': 0}}
{'OP': 'STOR', 'dst': {'same': False, 'type': 'addresses_PSE', 'NT': False, 'AVXalign': False, 'size': 32, 'congruent': 11}}
{'OP': 'STOR', 'dst': {'same': False, 'type': 'addresses_PSE', 'NT': False, 'AVXalign': True, 'size': 4, 'congruent': 1}}
{'OP': 'STOR', 'dst': {'same': False, 'type': 'addresses_WC', 'NT': False, 'AVXalign': False, 'size': 4, 'congruent': 7}}
[Faulty Load]
{'OP': 'LOAD', 'src': {'same': True, 'type': 'addresses_A', 'NT': False, 'AVXalign': False, 'size': 16, 'congruent': 0}}
<gen_prepare_buffer>
{'OP': 'LOAD', 'src': {'same': False, 'type': 'addresses_A_ht', 'NT': False, 'AVXalign': False, 'size': 1, 'congruent': 0}}
{'OP': 'LOAD', 'src': {'same': False, 'type': 'addresses_WC_ht', 'NT': False, 'AVXalign': True, 'size': 32, 'congruent': 6}}
{'OP': 'STOR', 'dst': {'same': False, 'type': 'addresses_WC_ht', 'NT': True, 'AVXalign': False, 'size': 16, 'congruent': 0}}
{'OP': 'REPM', 'src': {'same': True, 'congruent': 10, 'type': 'addresses_A_ht'}, 'dst': {'same': False, 'congruent': 8, 'type': 'addresses_WT_ht'}}
{'OP': 'LOAD', 'src': {'same': False, 'type': 'addresses_UC_ht', 'NT': False, 'AVXalign': False, 'size': 1, 'congruent': 2}}
{'OP': 'LOAD', 'src': {'same': False, 'type': 'addresses_WT_ht', 'NT': True, 'AVXalign': True, 'size': 1, 'congruent': 11}}
{'OP': 'REPM', 'src': {'same': False, 'congruent': 5, 'type': 'addresses_WC_ht'}, 'dst': {'same': False, 'congruent': 5, 'type': 'addresses_WC_ht'}}
{'OP': 'REPM', 'src': {'same': False, 'congruent': 9, 'type': 'addresses_normal_ht'}, 'dst': {'same': False, 'congruent': 6, 'type': 'addresses_WT_ht'}}
{'OP': 'LOAD', 'src': {'same': False, 'type': 'addresses_WT_ht', 'NT': False, 'AVXalign': False, 'size': 8, 'congruent': 9}}
{'OP': 'STOR', 'dst': {'same': False, 'type': 'addresses_WT_ht', 'NT': False, 'AVXalign': False, 'size': 4, 'congruent': 5}}
{'OP': 'REPM', 'src': {'same': True, 'congruent': 5, 'type': 'addresses_normal_ht'}, 'dst': {'same': False, 'congruent': 4, 'type': 'addresses_UC_ht'}}
{'OP': 'LOAD', 'src': {'same': False, 'type': 'addresses_WT_ht', 'NT': False, 'AVXalign': False, 'size': 4, 'congruent': 9}}
{'35': 21829}
35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35
*/
|
;===============================================================================
; Copyright 2015-2018 Intel Corporation
; All Rights Reserved.
;
; If this software was obtained under the Intel Simplified Software License,
; the following terms apply:
;
; The source code, information and material ("Material") contained herein is
; owned by Intel Corporation or its suppliers or licensors, and title to such
; Material remains with Intel Corporation or its suppliers or licensors. The
; Material contains proprietary information of Intel or its suppliers and
; licensors. The Material is protected by worldwide copyright laws and treaty
; provisions. No part of the Material may be used, copied, reproduced,
; modified, published, uploaded, posted, transmitted, distributed or disclosed
; in any way without Intel's prior express written permission. No license under
; any patent, copyright or other intellectual property rights in the Material
; is granted to or conferred upon you, either expressly, by implication,
; inducement, estoppel or otherwise. Any license under such intellectual
; property rights must be express and approved by Intel in writing.
;
; Unless otherwise agreed by Intel in writing, you may not remove or alter this
; notice or any other notice embedded in Materials by Intel or Intel's
; suppliers or licensors in any way.
;
;
; If this software was obtained under the Apache License, Version 2.0 (the
; "License"), the following terms apply:
;
; You may not use this file except in compliance with the License. You may
; obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
;
;
; Unless required by applicable law or agreed to in writing, software
; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
;
; See the License for the specific language governing permissions and
; limitations under the License.
;===============================================================================
;
;
; Purpose: Cryptography Primitive.
; Message block processing according to SHA1
;
; Content:
; UpdateSHA1
;
;
include asmdefs.inc
include ia_32e.inc
include pcpvariant.inc
IF (_ENABLE_ALG_SHA1_)
IF (_SHA_NI_ENABLING_ EQ _FEATURE_OFF_) OR (_SHA_NI_ENABLING_ EQ _FEATURE_TICKTOCK_)
IF (_IPP32E GE _IPP32E_M7) AND (_IPP32E LT _IPP32E_U8 )
;;
;; Magic functions defined in FIPS 180-1
;;
MAGIC_F0 MACRO regF:REQ,regB:REQ,regC:REQ,regD:REQ,regT ;; ((D ^ (B & (C ^ D)))
mov regF,regC
xor regF,regD
and regF,regB
xor regF,regD
ENDM
MAGIC_F1 MACRO regF:REQ,regB:REQ,regC:REQ,regD:REQ,regT ;; (B ^ C ^ D)
mov regF,regD
xor regF,regC
xor regF,regB
ENDM
MAGIC_F2 MACRO regF:REQ,regB:REQ,regC:REQ,regD:REQ,regT:REQ ;; ((B & C) | (B & D) | (C & D))
mov regF,regB
mov regT,regB
or regF,regC
and regT,regC
and regF,regD
or regF,regT
ENDM
MAGIC_F3 MACRO regF:REQ,regB:REQ,regC:REQ,regD:REQ,regT
MAGIC_F1 regF,regB,regC,regD,regT
ENDM
;;
;; single SHA1 step
;;
;; Ipp32u tmp = ROL(A,5) + MAGIC_Fi(B,C,D) + E + W[t] + CNT[i];
;; E = D;
;; D = C;
;; C = ROL(B,30);
;; B = A;
;; A = tmp;
;;
SHA1_STEP MACRO regA:REQ,regB:REQ,regC:REQ,regD:REQ,regE:REQ, regT:REQ,regF:REQ, memW:REQ, immCNT:REQ, MAGIC:REQ
add regE,immCNT
add regE,[memW]
mov regT,regA
rol regT,5
add regE,regT
MAGIC regF,regB,regC,regD,regT ;; FUN = MAGIC_Fi(B,C,D)
rol regB,30
add regE,regF
ENDM
SHA1_RND0 MACRO regA:REQ,regB:REQ,regC:REQ,regD:REQ,regE:REQ, regT:REQ,regF:REQ, nr:REQ
immCNT = 05A827999h
mov r13d,immCNT
MAGIC_F0 regF,regB,regC,regD ;; FUN = MAGIC_Fi(B,C,D)
ror regB,(32-30)
mov regT,regA
rol regT,5
add regE,[rsp+(((nr) and 0Fh)*4)]
; lea regE,[regE+regF+immCNT] ; substituted with 2 adds because of gnu as bug
add r13d, regF
add regE, r13d
add regE,regT
ENDM
SHA1_RND1 MACRO regA:REQ,regB:REQ,regC:REQ,regD:REQ,regE:REQ, regT:REQ,regF:REQ, nr:REQ
immCNT = 06ED9EBA1h
mov r13d,immCNT
MAGIC_F1 regF,regB,regC,regD ;; FUN = MAGIC_Fi(B,C,D)
ror regB,(32-30)
mov regT,regA
rol regT,5
add regE,[rsp+(((nr) and 0Fh)*4)]
; lea regE,[regE+regF+immCNT] ; substituted with 2 adds because of gnu as bug
add r13d, regF
add regE, r13d
add regE,regT
ENDM
SHA1_RND2 MACRO regA:REQ,regB:REQ,regC:REQ,regD:REQ,regE:REQ, regT:REQ,regF:REQ, nr:REQ
IFNDEF _VXWORKS
immCNT = 08F1BBCDCh
ELSE
immCNT = -1894007588
ENDIF
mov r13d,immCNT
MAGIC_F2 regF,regB,regC,regD,regT ;; FUN = MAGIC_Fi(B,C,D)
ror regB,(32-30)
mov regT,regA
rol regT,5
add regE,[rsp+(((nr) and 0Fh)*4)]
; lea regE,[regE+regF+immCNT] ; substituted with 2 adds because of gnu as bug
add r13d, regF
add regE, r13d
add regE,regT
ENDM
SHA1_RND3 MACRO regA:REQ,regB:REQ,regC:REQ,regD:REQ,regE:REQ, regT:REQ,regF:REQ, nr:REQ
IFNDEF _VXWORKS
immCNT = 0CA62C1D6h
ELSE
immCNT = -899497514
ENDIF
mov r13d,immCNT
MAGIC_F3 regF,regB,regC,regD ;; FUN = MAGIC_Fi(B,C,D)
ror regB,(32-30)
mov regT,regA
rol regT,5
add regE,[rsp+(((nr) and 0Fh)*4)]
; lea regE,[regE+regF+immCNT] ; substituted with 2 adds because of gnu as bug
add r13d, regF
add regE, r13d
add regE,regT
ENDM
;;
;; ENDIANNESS
;;
ENDIANNESS MACRO dst:REQ,src:REQ
IFDIF <dst>,<src>
mov dst,src
ENDIF
bswap dst
ENDM
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; Following Macros are especially for new implementation of SHA1
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
UPDATE MACRO nr:REQ,regU:REQ,regT
ifb <regT>
mov regU,[rsp+((nr-16) and 0Fh)*4]
xor regU,[rsp+((nr-14) and 0Fh)*4]
xor regU,[rsp+((nr-8) and 0Fh)*4]
xor regU,[rsp+((nr-3) and 0Fh)*4]
else
mov regU,[rsp+((nr-16) and 0Fh)*4]
mov regT,[rsp+((nr-14) and 0Fh)*4]
xor regU,regT
mov regT,[rsp+((nr-8) and 0Fh)*4]
xor regU,regT
mov regT,[rsp+((nr-3) and 0Fh)*4]
xor regU,regT
endif
rol regU,1
mov [rsp+(nr and 0Fh)*4],regU
ENDM
IPPCODE SEGMENT 'CODE' ALIGN (IPP_ALIGN_FACTOR)
;*****************************************************************************************
;* Purpose: Update internal digest according to message block
;*
;* void UpdateSHA1(DigestSHA1 digest, const Ipp32u* mblk, int mlen, const void* pParam)
;*
;*****************************************************************************************
;;
;; Lib = M7
;;
;; Caller = ippsSHA1Update
;; Caller = ippsSHA1Final
;; Caller = ippsSHA1MessageDigest
;;
;; Caller = ippsHMACSHA1Update
;; Caller = ippsHMACSHA1Final
;; Caller = ippsHMACSHA1MessageDigest
;;
ALIGN IPP_ALIGN_FACTOR
IPPASM UpdateSHA1 PROC PUBLIC FRAME
USES_GPR rbx,rsi,rdi,r8,r9,r10,r11,r12,r13
LOCAL_FRAME = 16*4
USES_XMM
COMP_ABI 4
MBS_SHA1 equ (64)
movsxd rdx, edx
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; process next data block
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
sha1_block_loop:
;;
;; init A, B, C, D, E by the internal digest
;;
mov r8d, [rdi+0*4] ; r8d = digest[0] (A)
mov r9d, [rdi+1*4] ; r9d = digest[1] (B)
mov r10d,[rdi+2*4] ; r10d= digest[2] (C)
mov r11d,[rdi+3*4] ; r11d= digest[3] (D)
mov r12d,[rdi+4*4] ; r12d= digest[4] (E)
;;
;; initialize the first 16 words in the array W (remember about endian)
;;
xor rcx,rcx
loop1:
mov eax,[rsi+rcx*4+0*4]
ENDIANNESS eax,eax
mov [rsp+rcx*4+0*4],eax
mov ebx,[rsi+rcx*4+1*4]
ENDIANNESS ebx,ebx
mov [rsp+rcx*4+1*4],ebx
add rcx,2
cmp rcx,16
jl loop1
;;
;; perform 0-79 steps
;;
;; A, B, C, D, E, TMP,FUN, round
;; -----------------------------------
SHA1_RND0 r8d,r9d,r10d,r11d,r12d, ecx,ebx, 0
UPDATE 16, eax
SHA1_RND0 r12d,r8d,r9d,r10d,r11d, ecx,ebx, 1
UPDATE 17, eax
SHA1_RND0 r11d,r12d,r8d,r9d,r10d, ecx,ebx, 2
UPDATE 18, eax
SHA1_RND0 r10d,r11d,r12d,r8d,r9d, ecx,ebx, 3
UPDATE 19, eax
SHA1_RND0 r9d,r10d,r11d,r12d,r8d, ecx,ebx, 4
UPDATE 20, eax
SHA1_RND0 r8d,r9d,r10d,r11d,r12d, ecx,ebx, 5
UPDATE 21, eax
SHA1_RND0 r12d,r8d,r9d,r10d,r11d, ecx,ebx, 6
UPDATE 22, eax
SHA1_RND0 r11d,r12d,r8d,r9d,r10d, ecx,ebx, 7
UPDATE 23, eax
SHA1_RND0 r10d,r11d,r12d,r8d,r9d, ecx,ebx, 8
UPDATE 24, eax
SHA1_RND0 r9d,r10d,r11d,r12d,r8d, ecx,ebx, 9
UPDATE 25, eax
SHA1_RND0 r8d,r9d,r10d,r11d,r12d, ecx,ebx, 10
UPDATE 26, eax
SHA1_RND0 r12d,r8d,r9d,r10d,r11d, ecx,ebx, 11
UPDATE 27, eax
SHA1_RND0 r11d,r12d,r8d,r9d,r10d, ecx,ebx, 12
UPDATE 28, eax
SHA1_RND0 r10d,r11d,r12d,r8d,r9d, ecx,ebx, 13
UPDATE 29, eax
SHA1_RND0 r9d,r10d,r11d,r12d,r8d, ecx,ebx, 14
UPDATE 30, eax
SHA1_RND0 r8d,r9d,r10d,r11d,r12d, ecx,ebx, 15
UPDATE 31, eax
SHA1_RND0 r12d,r8d,r9d,r10d,r11d, ecx,ebx, 16
UPDATE 32, eax
SHA1_RND0 r11d,r12d,r8d,r9d,r10d, ecx,ebx, 17
UPDATE 33, eax
SHA1_RND0 r10d,r11d,r12d,r8d,r9d, ecx,ebx, 18
UPDATE 34, eax
SHA1_RND0 r9d,r10d,r11d,r12d,r8d, ecx,ebx, 19
UPDATE 35, eax
SHA1_RND1 r8d,r9d,r10d,r11d,r12d, ecx,ebx, 20
UPDATE 36, eax
SHA1_RND1 r12d,r8d,r9d,r10d,r11d, ecx,ebx, 21
UPDATE 37, eax
SHA1_RND1 r11d,r12d,r8d,r9d,r10d, ecx,ebx, 22
UPDATE 38, eax
SHA1_RND1 r10d,r11d,r12d,r8d,r9d, ecx,ebx, 23
UPDATE 39, eax
SHA1_RND1 r9d,r10d,r11d,r12d,r8d, ecx,ebx, 24
UPDATE 40, eax
SHA1_RND1 r8d,r9d,r10d,r11d,r12d, ecx,ebx, 25
UPDATE 41, eax
SHA1_RND1 r12d,r8d,r9d,r10d,r11d, ecx,ebx, 26
UPDATE 42, eax
SHA1_RND1 r11d,r12d,r8d,r9d,r10d, ecx,ebx, 27
UPDATE 43, eax
SHA1_RND1 r10d,r11d,r12d,r8d,r9d, ecx,ebx, 28
UPDATE 44, eax
SHA1_RND1 r9d,r10d,r11d,r12d,r8d, ecx,ebx, 29
UPDATE 45, eax
SHA1_RND1 r8d,r9d,r10d,r11d,r12d, ecx,ebx, 30
UPDATE 46, eax
SHA1_RND1 r12d,r8d,r9d,r10d,r11d, ecx,ebx, 31
UPDATE 47, eax
SHA1_RND1 r11d,r12d,r8d,r9d,r10d, ecx,ebx, 32
UPDATE 48, eax
SHA1_RND1 r10d,r11d,r12d,r8d,r9d, ecx,ebx, 33
UPDATE 49, eax
SHA1_RND1 r9d,r10d,r11d,r12d,r8d, ecx,ebx, 34
UPDATE 50, eax
SHA1_RND1 r8d,r9d,r10d,r11d,r12d, ecx,ebx, 35
UPDATE 51, eax
SHA1_RND1 r12d,r8d,r9d,r10d,r11d, ecx,ebx, 36
UPDATE 52, eax
SHA1_RND1 r11d,r12d,r8d,r9d,r10d, ecx,ebx, 37
UPDATE 53, eax
SHA1_RND1 r10d,r11d,r12d,r8d,r9d, ecx,ebx, 38
UPDATE 54, eax
SHA1_RND1 r9d,r10d,r11d,r12d,r8d, ecx,ebx, 39
UPDATE 55, eax
SHA1_RND2 r8d,r9d,r10d,r11d,r12d, ecx,ebx, 40
UPDATE 56, eax
SHA1_RND2 r12d,r8d,r9d,r10d,r11d, ecx,ebx, 41
UPDATE 57, eax
SHA1_RND2 r11d,r12d,r8d,r9d,r10d, ecx,ebx, 42
UPDATE 58, eax
SHA1_RND2 r10d,r11d,r12d,r8d,r9d, ecx,ebx, 43
UPDATE 59, eax
SHA1_RND2 r9d,r10d,r11d,r12d,r8d, ecx,ebx, 44
UPDATE 60, eax
SHA1_RND2 r8d,r9d,r10d,r11d,r12d, ecx,ebx, 45
UPDATE 61, eax
SHA1_RND2 r12d,r8d,r9d,r10d,r11d, ecx,ebx, 46
UPDATE 62, eax
SHA1_RND2 r11d,r12d,r8d,r9d,r10d, ecx,ebx, 47
UPDATE 63, eax
SHA1_RND2 r10d,r11d,r12d,r8d,r9d, ecx,ebx, 48
UPDATE 64, eax
SHA1_RND2 r9d,r10d,r11d,r12d,r8d, ecx,ebx, 49
UPDATE 65, eax
SHA1_RND2 r8d,r9d,r10d,r11d,r12d, ecx,ebx, 50
UPDATE 66, eax
SHA1_RND2 r12d,r8d,r9d,r10d,r11d, ecx,ebx, 51
UPDATE 67, eax
SHA1_RND2 r11d,r12d,r8d,r9d,r10d, ecx,ebx, 52
UPDATE 68, eax
SHA1_RND2 r10d,r11d,r12d,r8d,r9d, ecx,ebx, 53
UPDATE 69, eax
SHA1_RND2 r9d,r10d,r11d,r12d,r8d, ecx,ebx, 54
UPDATE 70, eax
SHA1_RND2 r8d,r9d,r10d,r11d,r12d, ecx,ebx, 55
UPDATE 71, eax
SHA1_RND2 r12d,r8d,r9d,r10d,r11d, ecx,ebx, 56
UPDATE 72, eax
SHA1_RND2 r11d,r12d,r8d,r9d,r10d, ecx,ebx, 57
UPDATE 73, eax
SHA1_RND2 r10d,r11d,r12d,r8d,r9d, ecx,ebx, 58
UPDATE 74, eax
SHA1_RND2 r9d,r10d,r11d,r12d,r8d, ecx,ebx, 59
UPDATE 75, eax
SHA1_RND3 r8d,r9d,r10d,r11d,r12d, ecx,ebx, 60
UPDATE 76, eax
SHA1_RND3 r12d,r8d,r9d,r10d,r11d, ecx,ebx, 61
UPDATE 77, eax
SHA1_RND3 r11d,r12d,r8d,r9d,r10d, ecx,ebx, 62
UPDATE 78, eax
SHA1_RND3 r10d,r11d,r12d,r8d,r9d, ecx,ebx, 63
UPDATE 79, eax
SHA1_RND3 r9d,r10d,r11d,r12d,r8d, ecx,ebx, 64
SHA1_RND3 r8d,r9d,r10d,r11d,r12d, ecx,ebx, 65
SHA1_RND3 r12d,r8d,r9d,r10d,r11d, ecx,ebx, 66
SHA1_RND3 r11d,r12d,r8d,r9d,r10d, ecx,ebx, 67
SHA1_RND3 r10d,r11d,r12d,r8d,r9d, ecx,ebx, 68
SHA1_RND3 r9d,r10d,r11d,r12d,r8d, ecx,ebx, 69
SHA1_RND3 r8d,r9d,r10d,r11d,r12d, ecx,ebx, 70
SHA1_RND3 r12d,r8d,r9d,r10d,r11d, ecx,ebx, 71
SHA1_RND3 r11d,r12d,r8d,r9d,r10d, ecx,ebx, 72
SHA1_RND3 r10d,r11d,r12d,r8d,r9d, ecx,ebx, 73
SHA1_RND3 r9d,r10d,r11d,r12d,r8d, ecx,ebx, 74
SHA1_RND3 r8d,r9d,r10d,r11d,r12d, ecx,ebx, 75
SHA1_RND3 r12d,r8d,r9d,r10d,r11d, ecx,ebx, 76
SHA1_RND3 r11d,r12d,r8d,r9d,r10d, ecx,ebx, 77
SHA1_RND3 r10d,r11d,r12d,r8d,r9d, ecx,ebx, 78
SHA1_RND3 r9d,r10d,r11d,r12d,r8d, ecx,ebx, 79
;;
;; update digest
;;
add [rdi+0*4],r8d ; advance digest
add [rdi+1*4],r9d
add [rdi+2*4],r10d
add [rdi+3*4],r11d
add [rdi+4*4],r12d
add rsi, MBS_SHA1
sub rdx, MBS_SHA1
jg sha1_block_loop
REST_XMM
REST_GPR
ret
IPPASM UpdateSHA1 ENDP
ENDIF ;; (_IPP32E GE _IPP32E_M7) AND (_IPP32E LT _IPP32E_U8 )
ENDIF ;; _FEATURE_OFF_ / _FEATURE_TICKTOCK_
ENDIF ;; _ENABLE_ALG_SHA1_
END
|
.global s_prepare_buffers
s_prepare_buffers:
push %r14
push %r9
push %rcx
push %rdi
push %rsi
lea addresses_WC_ht+0x10d18, %rsi
lea addresses_UC_ht+0x10798, %rdi
nop
nop
cmp $23264, %r14
mov $65, %rcx
rep movsq
nop
nop
nop
nop
nop
sub $35100, %r9
lea addresses_normal_ht+0x2f98, %rdi
nop
xor $22460, %rcx
mov (%rdi), %si
nop
cmp %r9, %r9
pop %rsi
pop %rdi
pop %rcx
pop %r9
pop %r14
ret
.global s_faulty_load
s_faulty_load:
push %r10
push %r11
push %r13
push %r15
push %r8
push %rax
push %rbx
// Store
lea addresses_D+0x6798, %r11
nop
xor $37269, %r15
movl $0x51525354, (%r11)
nop
nop
nop
nop
nop
xor %r13, %r13
// Load
lea addresses_normal+0xce98, %r8
nop
xor $16465, %r10
mov (%r8), %ebx
xor %r15, %r15
// Faulty Load
lea addresses_WT+0x17798, %rax
nop
nop
nop
nop
xor %r10, %r10
vmovups (%rax), %ymm3
vextracti128 $0, %ymm3, %xmm3
vpextrq $1, %xmm3, %r11
lea oracles, %r8
and $0xff, %r11
shlq $12, %r11
mov (%r8,%r11,1), %r11
pop %rbx
pop %rax
pop %r8
pop %r15
pop %r13
pop %r11
pop %r10
ret
/*
<gen_faulty_load>
[REF]
{'src': {'same': False, 'congruent': 0, 'NT': False, 'type': 'addresses_WT', 'size': 2, 'AVXalign': False}, 'OP': 'LOAD'}
{'OP': 'STOR', 'dst': {'same': False, 'congruent': 8, 'NT': False, 'type': 'addresses_D', 'size': 4, 'AVXalign': False}}
{'src': {'same': False, 'congruent': 6, 'NT': False, 'type': 'addresses_normal', 'size': 4, 'AVXalign': False}, 'OP': 'LOAD'}
[Faulty Load]
{'src': {'same': True, 'congruent': 0, 'NT': False, 'type': 'addresses_WT', 'size': 32, 'AVXalign': False}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'src': {'type': 'addresses_WC_ht', 'congruent': 7, 'same': False}, 'OP': 'REPM', 'dst': {'type': 'addresses_UC_ht', 'congruent': 11, 'same': False}}
{'src': {'same': False, 'congruent': 8, 'NT': False, 'type': 'addresses_normal_ht', 'size': 2, 'AVXalign': False}, 'OP': 'LOAD'}
{'39': 21829}
39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39
*/
|
// Copyright (c) 2011-2015 The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#if defined(HAVE_CONFIG_H)
#include "config/kekcoin-config.h"
#endif
#include "splashscreen.h"
#include "networkstyle.h"
#include "clientversion.h"
#include "init.h"
#include "util.h"
#include "ui_interface.h"
#include "version.h"
#ifdef ENABLE_WALLET
#include "wallet/wallet.h"
#endif
#include <QApplication>
#include <QCloseEvent>
#include <QDesktopWidget>
#include <QPainter>
#include <QRadialGradient>
SplashScreen::SplashScreen(Qt::WindowFlags f, const NetworkStyle *networkStyle) :
QWidget(0, f), curAlignment(0)
{
// set reference point, paddings
int paddingRight = 50;
int titleVersionVSpace = 17;
float fontFactor = 1.0;
float devicePixelRatio = 1.0;
#if QT_VERSION > 0x050100
devicePixelRatio = ((QGuiApplication*)QCoreApplication::instance())->devicePixelRatio();
#endif
// define text to place
QString titleText = tr(PACKAGE_NAME);
QString versionText = QString("Version %1").arg(QString::fromStdString(FormatFullVersion()));
QString copyrightText = QString::fromUtf8(CopyrightHolders(strprintf("\xc2\xA9 %u-%u ", 2009, COPYRIGHT_YEAR)).c_str());
QString titleAddText = networkStyle->getTitleAddText();
QString font = QApplication::font().toString();
// create a bitmap according to device pixelratio
QSize splashSize(480*devicePixelRatio,320*devicePixelRatio);
pixmap = QPixmap(splashSize);
#if QT_VERSION > 0x050100
// change to HiDPI if it makes sense
pixmap.setDevicePixelRatio(devicePixelRatio);
#endif
QPainter pixPaint(&pixmap);
pixPaint.setPen(QColor(100,100,100));
// draw a slightly radial gradient
QRadialGradient gradient(QPoint(0,0), splashSize.width()/devicePixelRatio);
gradient.setColorAt(0, Qt::white);
gradient.setColorAt(1, QColor(247,247,247));
QRect rGradient(QPoint(0,0), splashSize);
pixPaint.fillRect(rGradient, gradient);
// draw the kekcoin icon, expected size of PNG: 1024x1024
QRect rectIcon(QPoint(0,0), QSize(480,320));
const QSize requiredSize(480,320);
QPixmap icon(":icons/splash");
pixPaint.drawPixmap(rectIcon, icon);
// check font size and drawing with
pixPaint.setFont(QFont(font, 33*fontFactor));
QFontMetrics fm = pixPaint.fontMetrics();
int titleTextWidth = fm.width(titleText);
if (titleTextWidth > 176) {
fontFactor = fontFactor * 176 / titleTextWidth;
}
pixPaint.setFont(QFont(font, 33*fontFactor));
fm = pixPaint.fontMetrics();
titleTextWidth = fm.width(titleText);
pixPaint.setFont(QFont(font, 12*fontFactor));
// if the version string is to long, reduce size
fm = pixPaint.fontMetrics();
int versionTextWidth = fm.width(versionText);
if(versionTextWidth > titleTextWidth+paddingRight-10) {
pixPaint.setFont(QFont(font, 10*fontFactor));
titleVersionVSpace -= 5;
}
pixPaint.drawText((pixmap.width()/devicePixelRatio)-titleTextWidth,15,versionText);
// draw copyright stuff
{
pixPaint.setFont(QFont(font, 10*fontFactor));
const int x = pixmap.width()/2;
const int y = pixmap.height()-80;
QRect copyrightRect(x, y, pixmap.width() - x - paddingRight, pixmap.height() - y);
}
// draw additional text if special network
if(!titleAddText.isEmpty()) {
QFont boldFont = QFont(font, 10*fontFactor);
boldFont.setWeight(QFont::Bold);
pixPaint.setFont(boldFont);
fm = pixPaint.fontMetrics();
int titleAddTextWidth = fm.width(titleAddText);
pixPaint.drawText(pixmap.width()/devicePixelRatio-titleAddTextWidth-10,15,titleAddText);
}
pixPaint.end();
// Set window title
setWindowTitle(titleText + " " + titleAddText);
// Resize window and move to center of desktop, disallow resizing
QRect r(QPoint(), QSize(pixmap.size().width()/devicePixelRatio,pixmap.size().height()/devicePixelRatio));
resize(r.size());
setFixedSize(r.size());
move(QApplication::desktop()->screenGeometry().center() - r.center());
subscribeToCoreSignals();
}
SplashScreen::~SplashScreen()
{
unsubscribeFromCoreSignals();
}
void SplashScreen::slotFinish(QWidget *mainWin)
{
Q_UNUSED(mainWin);
/* If the window is minimized, hide() will be ignored. */
/* Make sure we de-minimize the splashscreen window before hiding */
if (isMinimized())
showNormal();
hide();
}
static void InitMessage(SplashScreen *splash, const std::string &message)
{
QMetaObject::invokeMethod(splash, "showMessage",
Qt::QueuedConnection,
Q_ARG(QString, QString::fromStdString(message)),
Q_ARG(int, Qt::AlignBottom|Qt::AlignHCenter),
Q_ARG(QColor, QColor(55,55,55)));
}
static void ShowProgress(SplashScreen *splash, const std::string &title, int nProgress)
{
InitMessage(splash, title + strprintf("%d", nProgress) + "%");
}
#ifdef ENABLE_WALLET
static void ConnectWallet(SplashScreen *splash, CWallet* wallet)
{
wallet->ShowProgress.connect(boost::bind(ShowProgress, splash, _1, _2));
}
#endif
void SplashScreen::subscribeToCoreSignals()
{
// Connect signals to client
uiInterface.InitMessage.connect(boost::bind(InitMessage, this, _1));
uiInterface.ShowProgress.connect(boost::bind(ShowProgress, this, _1, _2));
#ifdef ENABLE_WALLET
uiInterface.LoadWallet.connect(boost::bind(ConnectWallet, this, _1));
#endif
}
void SplashScreen::unsubscribeFromCoreSignals()
{
// Disconnect signals from client
uiInterface.InitMessage.disconnect(boost::bind(InitMessage, this, _1));
uiInterface.ShowProgress.disconnect(boost::bind(ShowProgress, this, _1, _2));
#ifdef ENABLE_WALLET
if(pwalletMain)
pwalletMain->ShowProgress.disconnect(boost::bind(ShowProgress, this, _1, _2));
#endif
}
void SplashScreen::showMessage(const QString &message, int alignment, const QColor &color)
{
curMessage = message;
curAlignment = alignment;
curColor = color;
update();
}
void SplashScreen::paintEvent(QPaintEvent *event)
{
QPainter painter(this);
painter.drawPixmap(0, 0, pixmap);
QRect r = rect().adjusted(15, 15, -15, -15);
painter.setPen(curColor);
painter.drawText(r, curAlignment, curMessage);
}
void SplashScreen::closeEvent(QCloseEvent *event)
{
StartShutdown(); // allows an "emergency" shutdown during startup
event->ignore();
}
|
section .text
global square_of_sum
square_of_sum:
mov eax, edi
.l1:
dec edi
jz .done
add eax, edi
jmp .l1
.done:
mul eax
ret
global sum_of_squares
sum_of_squares:
xor ecx, ecx
.l1:
mov eax, edi
mul eax
add ecx, eax
dec edi
jnz .l1
mov eax, ecx
ret
global difference_of_squares
difference_of_squares:
push rbx
push rdi
call square_of_sum
mov ebx, eax
pop rdi
call sum_of_squares
sub ebx, eax
mov eax, ebx
pop rbx
ret
|
-- HUMAN RESOURCE MACHINE PROGRAM --
a:
COPYFROM 5
COPYTO 0
b:
INBOX
JUMPZ c
ADD 0
COPYTO 0
JUMP b
c:
COPYFROM 0
OUTBOX
JUMP a
DEFINE LABEL 0
eJzTYWBgyOCZvqZTfOfaedIhq2Jk3i+LkXk8N0UyYMIHkXvNznyXqlZxc5R4cy8p4OT5k5XAL5i8TpQl
CqiN4a76nywbjaqGT9oH5/Drui9MMxBcUW0SsmqGqdHKCRYs89davu7xs9xQudXsViZI/XH3zEWr3Opm
ebtdqmr1uJXJ6GWUMssnJPWj/5ICj+DJk5YHp3bMC0vIuxFxK5MrbmeGS0JCXmLihkr5pINzQPq3/zu6
jWEUjIJRQFUAAMUuR4E;
DEFINE LABEL 5
eJwzZmBgOGrwftk86ffLRIXVFoQLHZzzQOpkt7nc3iYu5VuZmcqCyfqKjyI2y88PqxGYHwZUzhAQcG2K
tY/1jC9O1jOiHa5NSbZd0VVsbp9bbH42ocP6e8AuBz2v4+56Xk88ArytfR5FWPusiX/i4V32xtWs7otT
VcMpq9mN7y0i6kFmFUa/X3Yh+k8WU2JdqE1yTMjktLpQkLhhsXfZ94LZjbfyrWdsLWSZf6r0/bKKmvfL
vtS6Lwyu2zI5upqjxK38eZFmmVYpSP2mLyGrGEbBKBgFJAMAQuNVuQ;
|
.global s_prepare_buffers
s_prepare_buffers:
push %r11
push %r14
push %rax
push %rbp
push %rbx
push %rcx
push %rdi
push %rsi
lea addresses_D_ht+0x1d986, %rsi
lea addresses_UC_ht+0x1e6a0, %rdi
add %r11, %r11
mov $123, %rcx
rep movsl
nop
nop
cmp %r14, %r14
lea addresses_normal_ht+0x1dbd8, %rsi
lea addresses_WT_ht+0x12818, %rdi
clflush (%rsi)
nop
nop
xor %rbx, %rbx
mov $84, %rcx
rep movsq
add $45630, %rdi
lea addresses_normal_ht+0xf7c2, %rsi
nop
nop
inc %rdi
vmovups (%rsi), %ymm7
vextracti128 $0, %ymm7, %xmm7
vpextrq $1, %xmm7, %r14
nop
nop
nop
dec %r11
lea addresses_A_ht+0x5bd8, %r14
add $37903, %rbp
mov (%r14), %ecx
nop
nop
nop
nop
sub $21914, %r11
lea addresses_WC_ht+0xb7d8, %rsi
lea addresses_WC_ht+0x167b8, %rdi
nop
xor $56101, %rax
mov $109, %rcx
rep movsb
xor $45007, %rbx
lea addresses_WT_ht+0x19dd8, %r11
nop
nop
add %rsi, %rsi
mov $0x6162636465666768, %rbp
movq %rbp, (%r11)
nop
add $7253, %r14
lea addresses_UC_ht+0x14998, %rsi
lea addresses_A_ht+0xbf3a, %rdi
clflush (%rsi)
nop
add $46653, %rbp
mov $55, %rcx
rep movsl
nop
nop
nop
sub %r14, %r14
lea addresses_WT_ht+0xae30, %rsi
lea addresses_WC_ht+0x53d8, %rdi
clflush (%rdi)
nop
add $19092, %r11
mov $25, %rcx
rep movsw
nop
nop
nop
sub %rsi, %rsi
lea addresses_UC_ht+0x14998, %rsi
lea addresses_D_ht+0x66d8, %rdi
nop
nop
nop
nop
cmp %r11, %r11
mov $26, %rcx
rep movsb
nop
nop
nop
nop
xor $37468, %rdi
lea addresses_UC_ht+0x5c10, %rbx
nop
nop
add $53671, %rbp
movups (%rbx), %xmm7
vpextrq $1, %xmm7, %r14
nop
nop
nop
nop
nop
inc %rbp
lea addresses_A_ht+0x11bd8, %rsi
lea addresses_WC_ht+0x127d8, %rdi
clflush (%rsi)
nop
nop
nop
xor %rax, %rax
mov $20, %rcx
rep movsw
and $64217, %r11
lea addresses_WC_ht+0xb198, %rcx
clflush (%rcx)
nop
xor %rsi, %rsi
movups (%rcx), %xmm5
vpextrq $0, %xmm5, %rbp
nop
nop
nop
sub %rbx, %rbx
lea addresses_D_ht+0x15858, %r11
nop
add $51026, %rbx
movb (%r11), %cl
nop
nop
xor $8566, %r11
lea addresses_D_ht+0x12fd8, %rbx
sub $63253, %rsi
movl $0x61626364, (%rbx)
nop
nop
nop
nop
and $54613, %rcx
lea addresses_UC_ht+0x1ebd8, %r11
nop
nop
nop
xor $8393, %rcx
mov (%r11), %r14d
nop
nop
nop
nop
nop
add %rdi, %rdi
pop %rsi
pop %rdi
pop %rcx
pop %rbx
pop %rbp
pop %rax
pop %r14
pop %r11
ret
.global s_faulty_load
s_faulty_load:
push %r10
push %r13
push %r14
push %r8
push %rax
push %rbp
// Store
lea addresses_D+0x17bd8, %r8
nop
nop
nop
nop
and $54993, %r13
movl $0x51525354, (%r8)
nop
nop
nop
cmp $18070, %r10
// Faulty Load
lea addresses_WT+0xf7d8, %r10
nop
add $6747, %rbp
vmovups (%r10), %ymm6
vextracti128 $0, %ymm6, %xmm6
vpextrq $0, %xmm6, %r13
lea oracles, %r14
and $0xff, %r13
shlq $12, %r13
mov (%r14,%r13,1), %r13
pop %rbp
pop %rax
pop %r8
pop %r14
pop %r13
pop %r10
ret
/*
<gen_faulty_load>
[REF]
{'src': {'type': 'addresses_WT', 'same': True, 'size': 2, 'congruent': 0, 'NT': True, 'AVXalign': False}, 'OP': 'LOAD'}
{'dst': {'type': 'addresses_D', 'same': True, 'size': 4, 'congruent': 6, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'}
[Faulty Load]
{'src': {'type': 'addresses_WT', 'same': True, 'size': 32, 'congruent': 0, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'src': {'type': 'addresses_D_ht', 'congruent': 0, 'same': False}, 'dst': {'type': 'addresses_UC_ht', 'congruent': 1, 'same': False}, 'OP': 'REPM'}
{'src': {'type': 'addresses_normal_ht', 'congruent': 8, 'same': False}, 'dst': {'type': 'addresses_WT_ht', 'congruent': 5, 'same': False}, 'OP': 'REPM'}
{'src': {'type': 'addresses_normal_ht', 'same': False, 'size': 32, 'congruent': 0, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
{'src': {'type': 'addresses_A_ht', 'same': False, 'size': 4, 'congruent': 9, 'NT': True, 'AVXalign': False}, 'OP': 'LOAD'}
{'src': {'type': 'addresses_WC_ht', 'congruent': 11, 'same': False}, 'dst': {'type': 'addresses_WC_ht', 'congruent': 5, 'same': False}, 'OP': 'REPM'}
{'dst': {'type': 'addresses_WT_ht', 'same': False, 'size': 8, 'congruent': 9, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'}
{'src': {'type': 'addresses_UC_ht', 'congruent': 5, 'same': False}, 'dst': {'type': 'addresses_A_ht', 'congruent': 1, 'same': False}, 'OP': 'REPM'}
{'src': {'type': 'addresses_WT_ht', 'congruent': 2, 'same': False}, 'dst': {'type': 'addresses_WC_ht', 'congruent': 10, 'same': False}, 'OP': 'REPM'}
{'src': {'type': 'addresses_UC_ht', 'congruent': 6, 'same': False}, 'dst': {'type': 'addresses_D_ht', 'congruent': 6, 'same': False}, 'OP': 'REPM'}
{'src': {'type': 'addresses_UC_ht', 'same': False, 'size': 16, 'congruent': 0, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
{'src': {'type': 'addresses_A_ht', 'congruent': 9, 'same': False}, 'dst': {'type': 'addresses_WC_ht', 'congruent': 10, 'same': False}, 'OP': 'REPM'}
{'src': {'type': 'addresses_WC_ht', 'same': False, 'size': 16, 'congruent': 5, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
{'src': {'type': 'addresses_D_ht', 'same': False, 'size': 1, 'congruent': 6, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
{'dst': {'type': 'addresses_D_ht', 'same': False, 'size': 4, 'congruent': 9, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'}
{'src': {'type': 'addresses_UC_ht', 'same': False, 'size': 4, 'congruent': 9, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
{'39': 21829}
39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39
*/
|
/*******************************************************************************
* Copyright 2020 FUJITSU LIMITED
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*******************************************************************************/
#include "test_generator2.h"
class TestPtnGenerator : public TestGenerator {
public:
void setInitialRegValue() {
/* Here modify arrays of inputGenReg, inputPredReg, inputZReg */
inputZReg[0].ud_dt[0] = uint64_t(0xabcd0123456789ab);
}
void setCheckRegFlagAll() {
/* Here modify arrays of checkGenRegMode, checkPredRegMode, checkZRegMode */
}
void genJitTestCode() {
/* Here write JIT code with x86_64 mnemonic function to be tested. */
/* Here write JIT code with x86_64 mnemonic function to be tested. */
/* RAX, RCX, RDX, RBX, RSP, RBP, RSI, RDI,
R8, R9, R10, R11, R12, R13, R14, R15 */
#define CMOV cmovz
size_t addr;
mov(r8, ~uint64_t(0));
mov(r9, ~uint64_t(0));
mov(r10, ~uint64_t(0));
mov(r11, ~uint64_t(0));
mov(r12, ~uint64_t(0));
mov(r13, ~uint64_t(0));
mov(rbp, ~uint64_t(0));
mov(rsi, ~uint64_t(0));
mov(rdi, ~uint64_t(0));
addr = reinterpret_cast<size_t>(&(inputZReg[0].ud_dt[0]));
mov(r15, addr);
mov(rax, uint64_t(2));
mov(rcx, uint64_t(1));
// 64 bits
// equal
cmp(rax, rax);
CMOV(r8, ptr[r15]);
// greater
cmp(rax, rcx);
CMOV(r9, ptr[r15]);
// less
cmp(rcx, rax);
CMOV(r10, ptr[r15]);
// 32 bits
// equal
cmp(rax, rax);
CMOV(r11d, ptr[r15]);
// greater
cmp(rax, rcx);
CMOV(r12d, ptr[r15]);
// less
cmp(rcx, rax);
CMOV(r13d, ptr[r15]);
// 16 bits
// equal
cmp(rax, rax);
CMOV(bp, ptr[r15]);
// greater
cmp(rax, rcx);
CMOV(si, ptr[r15]);
// less
cmp(rcx, rax);
CMOV(di, ptr[r15]);
mov(r15, 5);
}
};
int main(int argc, char *argv[]) {
/* Initializing arrays of inputData, inputGenReg, inputPredReg, inputZReg,
* checkGenRegMode, checkPredRegMode,checkZRegMode */
TestPtnGenerator gen;
/* Set bool output_jit_on_, bool exec_jit_on_ = 0; */
gen.parseArgs(argc, argv);
/* Generate JIT code and get function pointer */
void (*f)();
if (gen.isOutputJitOn()) {
f = (void (*)())gen.gen();
}
/* Dump generated JIT code to a binary file */
gen.dumpJitCode();
/* 1:Execute JIT code, 2:dump all register values, 3:dump register values to
* be checked */
if (gen.isExecJitOn()) {
/* Before executing JIT code, dump inputData, inputGenReg, inputPredReg,
* inputZReg. */
gen.dumpInputReg();
f(); /* Execute JIT code */
gen.dumpOutputReg(); /* Dump all register values */
gen.dumpCheckReg(); /* Dump register values to be checked */
}
return 0;
}
|
; A194386: Numbers m such that Sum_{k=1..m} (<1/2 + k*r> - <k*r>) > 0, where r=sqrt(10) and < > denotes fractional part.
; 1,2,3,4,5,7,8,9,10,11,13,14,15,16,17,19,20,21,22,23,25,26,27,28,29,31,32,33,34,35,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75
mov $2,$0
div $0,5
lpb $0
mov $0,6
lpe
add $0,1
add $0,$2
|
/*
* Copyright (c) Facebook, Inc. and its affiliates.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "velox/core/PlanNode.h"
namespace facebook::velox::core {
const SortOrder kAscNullsFirst(true, true);
const SortOrder kAscNullsLast(true, false);
const SortOrder kDescNullsFirst(false, true);
const SortOrder kDescNullsLast(false, false);
namespace {
const std::vector<PlanNodePtr> kEmptySources;
RowTypePtr getAggregationOutputType(
const std::vector<FieldAccessTypedExprPtr>& groupingKeys,
const std::vector<std::string>& aggregateNames,
const std::vector<CallTypedExprPtr>& aggregates) {
VELOX_CHECK_EQ(
aggregateNames.size(),
aggregates.size(),
"Number of aggregate names must be equal to number of aggregates");
std::vector<std::string> names;
std::vector<TypePtr> types;
for (auto& key : groupingKeys) {
auto field =
std::dynamic_pointer_cast<const core::FieldAccessTypedExpr>(key);
VELOX_CHECK(field, "Grouping key must be a field reference");
names.push_back(field->name());
types.push_back(field->type());
}
for (int32_t i = 0; i < aggregateNames.size(); i++) {
names.push_back(aggregateNames[i]);
types.push_back(aggregates[i]->type());
}
return std::make_shared<RowType>(std::move(names), std::move(types));
}
} // namespace
AggregationNode::AggregationNode(
const PlanNodeId& id,
Step step,
const std::vector<FieldAccessTypedExprPtr>& groupingKeys,
const std::vector<FieldAccessTypedExprPtr>& preGroupedKeys,
const std::vector<std::string>& aggregateNames,
const std::vector<CallTypedExprPtr>& aggregates,
const std::vector<FieldAccessTypedExprPtr>& aggregateMasks,
bool ignoreNullKeys,
PlanNodePtr source)
: PlanNode(id),
step_(step),
groupingKeys_(groupingKeys),
preGroupedKeys_(preGroupedKeys),
aggregateNames_(aggregateNames),
aggregates_(aggregates),
aggregateMasks_(aggregateMasks),
ignoreNullKeys_(ignoreNullKeys),
sources_{source},
outputType_(getAggregationOutputType(
groupingKeys_,
aggregateNames_,
aggregates_)) {
// Empty grouping keys are used in global aggregation:
// SELECT sum(c) FROM t
// Empty aggregates are used in distinct:
// SELECT distinct(b, c) FROM t GROUP BY a
VELOX_CHECK(
!groupingKeys_.empty() || !aggregates_.empty(),
"Aggregation must specify either grouping keys or aggregates");
std::unordered_set<std::string> groupingKeyNames;
groupingKeyNames.reserve(groupingKeys.size());
for (const auto& key : groupingKeys) {
groupingKeyNames.insert(key->name());
}
for (const auto& key : preGroupedKeys) {
VELOX_CHECK_EQ(
1,
groupingKeyNames.count(key->name()),
"Pre-grouped key must be one of the grouping keys: {}.",
key->name());
}
}
namespace {
void addFields(
std::stringstream& stream,
const std::vector<FieldAccessTypedExprPtr>& keys) {
for (auto i = 0; i < keys.size(); ++i) {
if (i > 0) {
stream << ", ";
}
stream << keys[i]->name();
}
}
void addKeys(std::stringstream& stream, const std::vector<TypedExprPtr>& keys) {
for (auto i = 0; i < keys.size(); ++i) {
const auto& expr = keys[i];
if (i > 0) {
stream << ", ";
}
if (auto field =
std::dynamic_pointer_cast<const core::FieldAccessTypedExpr>(expr)) {
stream << field->name();
} else if (
auto constant =
std::dynamic_pointer_cast<const core::ConstantTypedExpr>(expr)) {
stream << constant->toString();
} else {
stream << expr->toString();
}
}
}
} // namespace
void AggregationNode::addDetails(std::stringstream& stream) const {
stream << stepName(step_) << " ";
if (!groupingKeys_.empty()) {
stream << "[";
addFields(stream, groupingKeys_);
stream << "] ";
}
for (auto i = 0; i < aggregateNames_.size(); ++i) {
if (i > 0) {
stream << ", ";
}
stream << aggregateNames_[i] << " := " << aggregates_[i]->toString();
}
}
namespace {
RowTypePtr getGroupIdOutputType(
const std::map<std::string, FieldAccessTypedExprPtr>&
outputGroupingKeyNames,
const std::vector<FieldAccessTypedExprPtr>& aggregationInputs,
const std::string& groupIdName) {
// Grouping keys come first, followed by aggregation inputs and groupId
// column.
auto numOutputs =
outputGroupingKeyNames.size() + aggregationInputs.size() + 1;
std::vector<std::string> names;
std::vector<TypePtr> types;
names.reserve(numOutputs);
types.reserve(numOutputs);
for (const auto& [name, groupingKey] : outputGroupingKeyNames) {
names.push_back(name);
types.push_back(groupingKey->type());
}
for (const auto& input : aggregationInputs) {
names.push_back(input->name());
types.push_back(input->type());
}
names.push_back(groupIdName);
types.push_back(BIGINT());
return ROW(std::move(names), std::move(types));
}
} // namespace
GroupIdNode::GroupIdNode(
PlanNodeId id,
std::vector<std::vector<FieldAccessTypedExprPtr>> groupingSets,
std::map<std::string, FieldAccessTypedExprPtr> outputGroupingKeyNames,
std::vector<FieldAccessTypedExprPtr> aggregationInputs,
std::string groupIdName,
PlanNodePtr source)
: PlanNode(std::move(id)),
sources_{source},
outputType_(getGroupIdOutputType(
outputGroupingKeyNames,
aggregationInputs,
groupIdName)),
groupingSets_(std::move(groupingSets)),
outputGroupingKeyNames_(std::move(outputGroupingKeyNames)),
aggregationInputs_(std::move(aggregationInputs)),
groupIdName_(std::move(groupIdName)) {
VELOX_CHECK_GE(
groupingSets_.size(),
2,
"GroupIdNode requires two or more grouping sets.");
}
void GroupIdNode::addDetails(std::stringstream& stream) const {
for (auto i = 0; i < groupingSets_.size(); ++i) {
if (i > 0) {
stream << ", ";
}
stream << "[";
addFields(stream, groupingSets_[i]);
stream << "]";
}
}
const std::vector<PlanNodePtr>& ValuesNode::sources() const {
return kEmptySources;
}
void ValuesNode::addDetails(std::stringstream& stream) const {
vector_size_t totalCount = 0;
for (const auto& vector : values_) {
totalCount += vector->size();
}
stream << totalCount << " rows in " << values_.size() << " vectors";
}
void ProjectNode::addDetails(std::stringstream& stream) const {
stream << "expressions: ";
for (auto i = 0; i < projections_.size(); i++) {
auto& projection = projections_[i];
if (i > 0) {
stream << ", ";
}
stream << "(" << names_[i] << ":" << projection->type()->toString() << ", "
<< projection->toString() << ")";
}
}
const std::vector<PlanNodePtr>& TableScanNode::sources() const {
return kEmptySources;
}
void TableScanNode::addDetails(std::stringstream& stream) const {
stream << tableHandle_->toString();
}
const std::vector<PlanNodePtr>& ExchangeNode::sources() const {
return kEmptySources;
}
void ExchangeNode::addDetails(std::stringstream& /* stream */) const {
// Nothing to add.
}
UnnestNode::UnnestNode(
const PlanNodeId& id,
std::vector<FieldAccessTypedExprPtr> replicateVariables,
std::vector<FieldAccessTypedExprPtr> unnestVariables,
const std::vector<std::string>& unnestNames,
const std::optional<std::string>& ordinalityName,
const PlanNodePtr& source)
: PlanNode(id),
replicateVariables_{std::move(replicateVariables)},
unnestVariables_{std::move(unnestVariables)},
withOrdinality_{ordinalityName.has_value()},
sources_{source} {
// Calculate output type. First come "replicate" columns, followed by
// "unnest" columns, followed by an optional ordinality column.
std::vector<std::string> names;
std::vector<TypePtr> types;
for (const auto& variable : replicateVariables_) {
names.emplace_back(variable->name());
types.emplace_back(variable->type());
}
int unnestIndex = 0;
for (const auto& variable : unnestVariables_) {
if (variable->type()->isArray()) {
names.emplace_back(unnestNames[unnestIndex++]);
types.emplace_back(variable->type()->asArray().elementType());
} else if (variable->type()->isMap()) {
const auto& mapType = variable->type()->asMap();
names.emplace_back(unnestNames[unnestIndex++]);
types.emplace_back(mapType.keyType());
names.emplace_back(unnestNames[unnestIndex++]);
types.emplace_back(mapType.valueType());
} else {
VELOX_FAIL(
"Unexpected type of unnest variable. Expected ARRAY or MAP, but got {}.",
variable->type()->toString());
}
}
if (ordinalityName.has_value()) {
names.emplace_back(ordinalityName.value());
types.emplace_back(BIGINT());
}
outputType_ = ROW(std::move(names), std::move(types));
}
void UnnestNode::addDetails(std::stringstream& stream) const {
addFields(stream, unnestVariables_);
}
AbstractJoinNode::AbstractJoinNode(
const PlanNodeId& id,
JoinType joinType,
const std::vector<FieldAccessTypedExprPtr>& leftKeys,
const std::vector<FieldAccessTypedExprPtr>& rightKeys,
TypedExprPtr filter,
PlanNodePtr left,
PlanNodePtr right,
const RowTypePtr outputType)
: PlanNode(id),
joinType_(joinType),
leftKeys_(leftKeys),
rightKeys_(rightKeys),
filter_(std::move(filter)),
sources_({std::move(left), std::move(right)}),
outputType_(outputType) {
VELOX_CHECK(!leftKeys_.empty(), "JoinNode requires at least one join key");
VELOX_CHECK_EQ(
leftKeys_.size(),
rightKeys_.size(),
"JoinNode requires same number of join keys on left and right sides");
if (isSemiJoin() || isAntiJoin()) {
VELOX_CHECK_NULL(filter, "Semi and anti join does not support filter");
}
auto leftType = sources_[0]->outputType();
for (auto key : leftKeys_) {
VELOX_CHECK(
leftType->containsChild(key->name()),
"Left side join key not found in left side output: {}",
key->name());
}
auto rightType = sources_[1]->outputType();
for (auto key : rightKeys_) {
VELOX_CHECK(
rightType->containsChild(key->name()),
"Right side join key not found in right side output: {}",
key->name());
}
for (auto i = 0; i < leftKeys_.size(); ++i) {
VELOX_CHECK_EQ(
leftKeys_[i]->type()->kind(),
rightKeys_[i]->type()->kind(),
"Join key types on the left and right sides must match");
}
for (auto i = 0; i < outputType_->size(); ++i) {
auto name = outputType_->nameOf(i);
if (leftType->containsChild(name)) {
VELOX_CHECK(
!rightType->containsChild(name),
"Duplicate column name found on join's left and right sides: {}",
name);
} else if (rightType->containsChild(name)) {
VELOX_CHECK(
!leftType->containsChild(name),
"Duplicate column name found on join's left and right sides: {}",
name);
} else {
VELOX_FAIL(
"Join's output column not found in either left or right sides: {}",
name);
}
}
}
void AbstractJoinNode::addDetails(std::stringstream& stream) const {
stream << joinTypeName(joinType_) << " ";
for (auto i = 0; i < leftKeys_.size(); ++i) {
if (i > 0) {
stream << " AND ";
}
stream << leftKeys_[i]->name() << "=" << rightKeys_[i]->name();
}
if (filter_) {
stream << ", filter: " << filter_->toString();
}
}
CrossJoinNode::CrossJoinNode(
const PlanNodeId& id,
PlanNodePtr left,
PlanNodePtr right,
RowTypePtr outputType)
: PlanNode(id),
sources_({std::move(left), std::move(right)}),
outputType_(std::move(outputType)) {}
void CrossJoinNode::addDetails(std::stringstream& /* stream */) const {
// Nothing to add.
}
AssignUniqueIdNode::AssignUniqueIdNode(
const PlanNodeId& id,
const std::string& idName,
const int32_t taskUniqueId,
PlanNodePtr source)
: PlanNode(id), taskUniqueId_(taskUniqueId), sources_{std::move(source)} {
std::vector<std::string> names(sources_[0]->outputType()->names());
std::vector<TypePtr> types(sources_[0]->outputType()->children());
names.emplace_back(idName);
types.emplace_back(BIGINT());
outputType_ = ROW(std::move(names), std::move(types));
uniqueIdCounter_ = std::make_shared<std::atomic_int64_t>();
}
void AssignUniqueIdNode::addDetails(std::stringstream& /* stream */) const {
// Nothing to add.
}
namespace {
void addSortingKeys(
std::stringstream& stream,
const std::vector<FieldAccessTypedExprPtr>& sortingKeys,
const std::vector<SortOrder>& sortingOrders) {
for (auto i = 0; i < sortingKeys.size(); ++i) {
if (i > 0) {
stream << ", ";
}
stream << sortingKeys[i]->name() << " " << sortingOrders[i].toString();
}
}
} // namespace
void LocalMergeNode::addDetails(std::stringstream& stream) const {
addSortingKeys(stream, sortingKeys_, sortingOrders_);
}
void TableWriteNode::addDetails(std::stringstream& /* stream */) const {
// TODO Add connector details.
}
void MergeExchangeNode::addDetails(std::stringstream& stream) const {
addSortingKeys(stream, sortingKeys_, sortingOrders_);
}
void LocalPartitionNode::addDetails(std::stringstream& stream) const {
// Nothing to add.
switch (type_) {
case Type::kGather:
stream << "GATHER";
break;
case Type::kRepartition:
stream << "REPARTITION";
break;
}
}
void EnforceSingleRowNode::addDetails(std::stringstream& /* stream */) const {
// Nothing to add.
}
void PartitionedOutputNode::addDetails(std::stringstream& stream) const {
if (broadcast_) {
stream << "BROADCAST";
} else if (numPartitions_ == 1) {
stream << "SINGLE";
} else {
stream << "HASH(";
addKeys(stream, keys_);
stream << ") " << numPartitions_;
}
if (replicateNullsAndAny_) {
stream << " replicate nulls and any";
}
}
void TopNNode::addDetails(std::stringstream& stream) const {
if (isPartial_) {
stream << "PARTIAL ";
}
stream << count_ << " ";
addSortingKeys(stream, sortingKeys_, sortingOrders_);
}
void LimitNode::addDetails(std::stringstream& stream) const {
if (isPartial_) {
stream << "PARTIAL ";
}
stream << count_;
if (offset_) {
stream << " offset " << offset_;
}
}
void OrderByNode::addDetails(std::stringstream& stream) const {
if (isPartial_) {
stream << "PARTIAL ";
}
addSortingKeys(stream, sortingKeys_, sortingOrders_);
}
void PlanNode::toString(
std::stringstream& stream,
bool detailed,
bool recursive,
size_t indentationSize,
std::function<void(
const PlanNodeId& planNodeId,
const std::string& indentation,
std::stringstream& stream)> addContext) const {
const std::string indentation(indentationSize, ' ');
stream << indentation << "-- " << name();
if (detailed) {
stream << "[";
addDetails(stream);
stream << "]";
stream << " -> ";
outputType()->printChildren(stream, ", ");
}
stream << std::endl;
if (addContext) {
auto contextIndentation = indentation + " ";
stream << contextIndentation;
addContext(id_, contextIndentation, stream);
stream << std::endl;
}
if (recursive) {
for (auto& source : sources()) {
source->toString(stream, detailed, true, indentationSize + 2, addContext);
}
}
}
namespace {
void collectLeafPlanNodeIds(
const core::PlanNode& planNode,
std::unordered_set<core::PlanNodeId>& leafIds) {
if (planNode.sources().empty()) {
leafIds.insert(planNode.id());
return;
}
for (const auto& child : planNode.sources()) {
collectLeafPlanNodeIds(*child, leafIds);
}
}
} // namespace
std::unordered_set<core::PlanNodeId> PlanNode::leafPlanNodeIds() const {
std::unordered_set<core::PlanNodeId> leafIds;
collectLeafPlanNodeIds(*this, leafIds);
return leafIds;
}
} // namespace facebook::velox::core
|
m: MACRO
shift -3
ENDM
m
|
.CR 8085 To load the 8085 cross overlay
.TF lcd_test.hex,INT,32
.OR $0000
MVI A,0EH
OUT 40H ;8155 con PB y PC como salidas
MVI A,8FH
OUT 63H ;8255 con PA como salidas
LXI SP,2FFFH ;Initialize Stack Pointer End of RAM 6264
CALL LCDINIT ;Inicializacion del LCD
CALL LCDMSG ;Imprime Hola mundo! en la primera linea
CALL LCDL2 ;Cursor en la segunda linea
CALL LCDMSG2 ;Imprime Intel 8085 ready en la seguna linea
LOOP: NOP
JMP LOOP
LCDINIT: MVI A,00H ;Rutina de inicialización para el LCD
OUT 43H ;RS=0,RW=0,E=0
CALL DELAY
MVI A, 30H ;Primer 30H
OUT 42H
CALL DELAY
CALL PULSOE
MVI A, 30H ;Segundo 30H
OUT 42H
CALL DELAY
CALL PULSOE
MVI A, 30H ;Tercer 30H
OUT 42H
CALL DELAY
CALL PULSOE
MVI A, 30H ;Tercer 30H
OUT 42H
CALL DELAY
CALL PULSOE
MVI A, 38H ;Primera funcion real
OUT 42H
CALL DELAY
CALL PULSOE
MVI A, 08H ;Display on/off control
OUT 42H
CALL DELAY
CALL PULSOE
MVI A, 01H ;Clear display
OUT 42H
CALL DELAY
CALL PULSOE
MVI A, 06H ;Entry mode set
OUT 42H
CALL DELAY
CALL PULSOE
MVI A, 0CH ;Display on/off control
OUT 42H
CALL DELAY
CALL PULSOE
RET
LCDMSG: MVI A, 01H ;Mensaje Hola mundo!
OUT 43H
MVI A, 'H'
OUT 42H
CALL PULSOE2
MVI A, 'o'
OUT 42H
CALL PULSOE2
MVI A, 'l'
OUT 42H
CALL PULSOE2
MVI A, 'a'
OUT 42H
CALL PULSOE2
MVI A, ' '
OUT 42H
CALL PULSOE2
MVI A, 'M'
OUT 42H
CALL PULSOE2
MVI A, 'u'
OUT 42H
CALL PULSOE2
MVI A, 'n'
OUT 42H
CALL PULSOE2
MVI A, 'd'
OUT 42H
CALL PULSOE2
MVI A, 'o'
OUT 42H
CALL PULSOE2
MVI A, '!'
OUT 42H
CALL PULSOE2
RET
LCDMSG2: MVI A, 01H ;Mensaje Intel 8085 ready
OUT 43H
MVI A, 'I'
OUT 42H
CALL PULSOE2
MVI A, 'n'
OUT 42H
CALL PULSOE2
MVI A, 't'
OUT 42H
CALL PULSOE2
MVI A, 'e'
OUT 42H
CALL PULSOE2
MVI A, 'l'
OUT 42H
CALL PULSOE2
MVI A, ' '
OUT 42H
CALL PULSOE2
MVI A, '8'
OUT 42H
CALL PULSOE2
MVI A, '0'
OUT 42H
CALL PULSOE2
MVI A, '8'
OUT 42H
CALL PULSOE2
MVI A, '5'
OUT 42H
CALL PULSOE2
MVI A, ' '
OUT 42H
CALL PULSOE2
MVI A, 'r'
OUT 42H
CALL PULSOE2
MVI A, 'e'
OUT 42H
CALL PULSOE2
MVI A, 'a'
OUT 42H
CALL PULSOE2
MVI A, 'd'
OUT 42H
CALL PULSOE2
MVI A, 'y'
OUT 42H
CALL PULSOE2
RET
LCDL2: MVI A,00H ;Comando para mover cursor a linea 2
OUT 43H
MVI A, 0C0H
OUT 42H
CALL DELAY
CALL PULSOE
RET
PULSOE2: MVI A, 05H ;Pulso en E para dato
OUT 43H
CALL DELAY
MVI A, 01H
OUT 43H
CALL DELAY
RET
PULSOE: MVI A, 04H ;Pulso en E para comando
OUT 43H
CALL DELAY
MVI A, 00H
OUT 43H
CALL DELAY
RET
DELAY: PUSH B ; Saving B. This delay subroutine uses 2 single registers A & D and 1 register pair BC
PUSH D
PUSH PSW ; Saving PSW
MVI D, 0FFH ; Loading counter for outer loop
ST: LXI B, 08H ; Loading counter for inner loop
L: DCX B ; Decrement inner counter
MOV A, C ; If not exhausted go again for inner loop
ORA B
JNZ L
DCR D ; Decrement outer counter
JNZ ST ; If not exhausted go again for outer loop
POP PSW ; Restore PSW
POP D
POP B ; Restore B
RET |
.global s_prepare_buffers
s_prepare_buffers:
push %r10
push %r9
push %rax
push %rbp
push %rbx
push %rcx
push %rdi
push %rsi
lea addresses_A_ht+0x66ed, %rsi
lea addresses_UC_ht+0x17d0d, %rdi
clflush (%rsi)
nop
xor $51850, %r9
mov $95, %rcx
rep movsq
nop
nop
nop
lfence
lea addresses_WT_ht+0xcb85, %r10
nop
nop
nop
nop
add %rax, %rax
mov $0x6162636465666768, %rcx
movq %rcx, (%r10)
nop
add %rax, %rax
lea addresses_WC_ht+0x696d, %rsi
lea addresses_WC_ht+0x32ed, %rdi
nop
nop
nop
nop
inc %rbx
mov $77, %rcx
rep movsq
nop
nop
nop
sub $42913, %rbx
lea addresses_normal_ht+0x1a751, %rbx
nop
nop
sub $44332, %r10
mov (%rbx), %si
nop
nop
nop
nop
nop
cmp %r9, %r9
lea addresses_WT_ht+0x1a6ed, %rbx
clflush (%rbx)
nop
nop
nop
nop
inc %r9
mov $0x6162636465666768, %rax
movq %rax, %xmm3
movups %xmm3, (%rbx)
nop
nop
nop
nop
nop
cmp %rbx, %rbx
lea addresses_A_ht+0x12ed, %r9
nop
nop
nop
nop
inc %rsi
mov (%r9), %cx
nop
nop
sub %rbx, %rbx
lea addresses_D_ht+0x22ed, %rsi
lea addresses_D_ht+0x435d, %rdi
dec %rbp
mov $46, %rcx
rep movsq
nop
nop
nop
and %rbp, %rbp
lea addresses_D_ht+0x324d, %rax
clflush (%rax)
dec %rdi
mov (%rax), %cx
nop
nop
nop
and %rax, %rax
lea addresses_D_ht+0x680d, %rbp
nop
nop
xor $7085, %r10
movl $0x61626364, (%rbp)
add %rbp, %rbp
lea addresses_A_ht+0xf5ed, %rcx
nop
nop
nop
inc %r10
vmovups (%rcx), %ymm6
vextracti128 $1, %ymm6, %xmm6
vpextrq $0, %xmm6, %rbp
nop
add %rdi, %rdi
lea addresses_D_ht+0x1327d, %r9
nop
nop
dec %rdi
mov $0x6162636465666768, %rax
movq %rax, (%r9)
sub %r9, %r9
pop %rsi
pop %rdi
pop %rcx
pop %rbx
pop %rbp
pop %rax
pop %r9
pop %r10
ret
.global s_faulty_load
s_faulty_load:
push %r10
push %r11
push %r15
push %rbp
push %rbx
push %rdi
push %rdx
// Load
lea addresses_D+0x1c04d, %r15
nop
nop
nop
nop
nop
add $22259, %rbp
mov (%r15), %dx
sub %rbp, %rbp
// Store
lea addresses_A+0xaaed, %r15
nop
nop
sub %r10, %r10
movw $0x5152, (%r15)
nop
nop
nop
nop
add $61628, %rdx
// Load
lea addresses_A+0x1d2ed, %r10
clflush (%r10)
nop
dec %r15
mov (%r10), %r11d
nop
nop
nop
nop
nop
and %r10, %r10
// Store
lea addresses_normal+0x1c86d, %rdx
nop
nop
cmp $16496, %rdi
mov $0x5152535455565758, %rbx
movq %rbx, %xmm6
vmovups %ymm6, (%rdx)
and $10552, %rbx
// Faulty Load
lea addresses_A+0x1d2ed, %r10
clflush (%r10)
nop
nop
xor %rdx, %rdx
vmovups (%r10), %ymm0
vextracti128 $0, %ymm0, %xmm0
vpextrq $1, %xmm0, %r11
lea oracles, %rdx
and $0xff, %r11
shlq $12, %r11
mov (%rdx,%r11,1), %r11
pop %rdx
pop %rdi
pop %rbx
pop %rbp
pop %r15
pop %r11
pop %r10
ret
/*
<gen_faulty_load>
[REF]
{'src': {'NT': True, 'same': False, 'congruent': 0, 'type': 'addresses_A', 'AVXalign': False, 'size': 1}, 'OP': 'LOAD'}
{'src': {'NT': False, 'same': False, 'congruent': 5, 'type': 'addresses_D', 'AVXalign': False, 'size': 2}, 'OP': 'LOAD'}
{'OP': 'STOR', 'dst': {'NT': False, 'same': False, 'congruent': 8, 'type': 'addresses_A', 'AVXalign': False, 'size': 2}}
{'src': {'NT': False, 'same': True, 'congruent': 0, 'type': 'addresses_A', 'AVXalign': True, 'size': 4}, 'OP': 'LOAD'}
{'OP': 'STOR', 'dst': {'NT': False, 'same': False, 'congruent': 4, 'type': 'addresses_normal', 'AVXalign': False, 'size': 32}}
[Faulty Load]
{'src': {'NT': False, 'same': True, 'congruent': 0, 'type': 'addresses_A', 'AVXalign': False, 'size': 32}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'src': {'same': False, 'congruent': 9, 'type': 'addresses_A_ht'}, 'OP': 'REPM', 'dst': {'same': False, 'congruent': 3, 'type': 'addresses_UC_ht'}}
{'OP': 'STOR', 'dst': {'NT': False, 'same': False, 'congruent': 3, 'type': 'addresses_WT_ht', 'AVXalign': False, 'size': 8}}
{'src': {'same': False, 'congruent': 6, 'type': 'addresses_WC_ht'}, 'OP': 'REPM', 'dst': {'same': False, 'congruent': 9, 'type': 'addresses_WC_ht'}}
{'src': {'NT': True, 'same': False, 'congruent': 0, 'type': 'addresses_normal_ht', 'AVXalign': False, 'size': 2}, 'OP': 'LOAD'}
{'OP': 'STOR', 'dst': {'NT': False, 'same': False, 'congruent': 9, 'type': 'addresses_WT_ht', 'AVXalign': False, 'size': 16}}
{'src': {'NT': False, 'same': False, 'congruent': 11, 'type': 'addresses_A_ht', 'AVXalign': False, 'size': 2}, 'OP': 'LOAD'}
{'src': {'same': False, 'congruent': 10, 'type': 'addresses_D_ht'}, 'OP': 'REPM', 'dst': {'same': False, 'congruent': 4, 'type': 'addresses_D_ht'}}
{'src': {'NT': False, 'same': False, 'congruent': 5, 'type': 'addresses_D_ht', 'AVXalign': False, 'size': 2}, 'OP': 'LOAD'}
{'OP': 'STOR', 'dst': {'NT': True, 'same': True, 'congruent': 5, 'type': 'addresses_D_ht', 'AVXalign': True, 'size': 4}}
{'src': {'NT': False, 'same': False, 'congruent': 5, 'type': 'addresses_A_ht', 'AVXalign': False, 'size': 32}, 'OP': 'LOAD'}
{'OP': 'STOR', 'dst': {'NT': False, 'same': False, 'congruent': 2, 'type': 'addresses_D_ht', 'AVXalign': False, 'size': 8}}
{'45': 2828, '46': 162, '00': 990, '48': 1090}
00 45 45 45 45 45 45 48 45 45 00 00 45 45 45 45 45 00 00 45 48 00 45 45 45 45 45 45 45 48 45 45 45 48 45 45 45 00 45 45 45 45 00 45 46 48 45 45 45 45 48 45 45 45 00 45 45 45 45 45 48 48 00 00 45 45 45 48 45 45 45 48 48 48 45 45 45 45 45 00 45 45 46 45 45 45 45 00 45 45 00 45 45 48 45 45 48 45 48 45 00 00 45 48 00 45 45 00 45 48 48 45 00 00 45 45 45 45 45 45 45 45 45 48 00 45 45 48 00 45 45 45 45 00 45 00 45 46 45 45 45 00 45 45 46 48 45 00 00 48 00 00 45 45 45 00 45 45 45 00 48 45 48 00 45 45 45 45 45 48 48 48 45 00 46 46 48 00 45 48 48 00 45 45 45 48 45 48 00 45 45 48 00 48 45 48 48 45 45 45 48 48 45 45 46 45 45 46 00 48 48 45 48 48 45 00 00 00 45 45 48 00 48 45 00 48 45 45 45 45 45 45 00 46 00 46 48 45 45 00 00 45 48 00 45 00 00 00 45 00 45 45 00 00 48 00 00 00 45 48 45 45 45 45 45 45 45 45 45 45 45 45 45 45 00 00 48 48 00 00 45 45 00 45 00 00 48 45 00 00 45 00 48 45 00 00 45 46 45 45 45 45 00 46 48 45 45 48 45 48 45 00 45 45 45 45 00 45 48 48 45 45 00 45 00 48 00 45 45 45 45 00 00 00 00 45 48 45 45 45 45 45 45 48 45 45 48 45 45 00 48 45 45 48 00 45 00 48 45 00 45 45 45 48 00 46 45 45 48 00 48 48 45 00 45 46 48 48 48 45 00 48 45 45 45 00 45 00 45 45 00 45 48 45 45 45 00 45 48 45 45 45 45 45 00 45 45 00 45 48 00 45 00 45 45 00 45 00 00 45 46 45 45 45 48 00 48 45 45 45 00 46 45 48 48 45 48 48 48 48 45 46 48 45 48 45 45 45 45 00 48 45 48 48 48 00 00 00 46 45 45 48 48 45 45 45 00 00 48 45 45 00 00 00 45 00 45 45 45 48 00 46 48 45 48 00 45 48 45 00 45 45 48 45 45 48 48 48 48 45 45 45 48 45 48 45 46 45 00 45 48 48 48 48 00 45 48 45 45 48 00 45 48 00 00 45 45 45 48 45 48 45 45 45 45 45 45 00 45 45 45 00 46 45 48 45 48 46 45 00 48 45 48 45 00 00 00 45 48 45 00 45 45 48 45 48 45 45 48 48 45 45 48 48 45 45 48 45 00 48 48 46 48 48 45 45 00 45 45 45 45 00 45 00 48 45 45 45 48 48 45 48 48 45 45 00 45 00 00 46 45 00 45 45 45 00 48 45 45 45 45 00 45 45 00 48 45 45 00 45 48 45 45 00 48 48 45 48 45 45 45 45 00 45 48 45 00 45 48 45 45 00 45 45 48 45 45 45 45 00 48 46 48 48 45 45 45 45 48 45 00 48 00 45 45 00 45 45 00 00 00 00 00 45 00 45 48 45 00 45 48 45 45 00 48 00 45 45 48 45 45 00 45 00 45 00 45 48 45 45 45 48 46 48 48 45 48 45 48 00 45 45 45 48 00 45 45 00 00 00 45 48 00 45 45 45 48 45 46 45 00 00 45 46 48 00 45 00 45 48 45 48 45 45 45 00 45 00 48 45 45 48 48 48 45 00 48 45 45 00 45 45 00 48 00 46 48 45 45 45 45 00 48 00 00 00 45 45 45 48 45 46 45 48 00 45 45 45 45 48 48 00 45 45 45 00 45 45 45 48 45 45 48 45 45 00 45 00 45 46 45 45 45 46 48 00 48 46 48 45 45 45 45 45 45 00 00 00 45 46 00 00 45 45 45 45 48 45 00 45 45 48 45 48 45 45 00 45 45 48 48 48 46 45 45 45 48 45 48 48 45 45 45 48 45 48 45 45 48 45 45 48 45 48 45 45 00 45 45 45 45 45 45 45 45 48 00 45 45 00 45 45 00 45 45 00 00 45 45 48 45 00 45 48 48 45 48 45 48 45 45 45 45 00 45 45 45 00 46 00 00 00 45 45 45 45 45 00 00 48 45 45 45 48 45 45 45 48 45 45 45 00 45 48 45 00 00 00 45 48 45 45 00 45 00 00 00 45 48 00 45 45 48 48 45 00 45 00 45 45 48 45 46 45 45 45 48 48 00 45 45 45 45 00 45 45 45 45 00 45
*/
|
; >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
; simplifying macros and functions
; makes a VDP address difference
vdpCommDelta function addr,((addr&$3FFF)<<16)|((addr&$C000)>>14)
; makes a VDP command
vdpComm function addr,type,rwd,(((type&rwd)&3)<<30)|((addr&$3FFF)<<16)|(((type&rwd)&$FC)<<2)|((addr&$C000)>>14)
; values for the type argument
VRAM = %100001
CRAM = %101011
VSRAM = %100101
; values for the rwd argument
READ = %001100
WRITE = %000111
DMA = %100111
; tells the VDP to copy a region of 68k memory to VRAM or CRAM or VSRAM
dma68kToVDP macro source,dest,length,type
lea (VDP_control_port).l,a5
move.l #(($9400|((((length)>>1)&$FF00)>>8))<<16)|($9300|(((length)>>1)&$FF)),(a5)
move.l #(($9600|((((source)>>1)&$FF00)>>8))<<16)|($9500|(((source)>>1)&$FF)),(a5)
move.w #$9700|(((((source)>>1)&$FF0000)>>16)&$7F),(a5)
move.w #((vdpComm(dest,type,DMA)>>16)&$FFFF),(a5)
move.w #(vdpComm(dest,type,DMA)&$FFFF),(DMA_data_thunk).w
move.w (DMA_data_thunk).w,(a5)
endm
; tells the VDP to fill a region of VRAM with a certain byte
dmaFillVRAM macro byte,addr,length
lea (VDP_control_port).l,a5
move.w #$8F01,(a5) ; VRAM pointer increment: $0001
move.l #(($9400|((((length)-1)&$FF00)>>8))<<16)|($9300|(((length)-1)&$FF)),(a5) ; DMA length ...
move.w #$9780,(a5) ; VRAM fill
move.l #$40000080|(((addr)&$3FFF)<<16)|(((addr)&$C000)>>14),(a5) ; Start at ...
move.w #(byte)<<8,(VDP_data_port).l ; Fill with byte
.loop: move.w (a5),d1
btst #1,d1
bne.s .loop ; busy loop until the VDP is finished filling...
move.w #$8F02,(a5) ; VRAM pointer increment: $0002
endm
; calculates initial loop counter value for a dbf loop
; that writes n bytes total at 4 bytes per iteration
bytesToLcnt function n,n>>2-1
; calculates initial loop counter value for a dbf loop
; that writes n bytes total at 2 bytes per iteration
bytesToWcnt function n,n>>1-1
; fills a region of 68k RAM with 0
clearRAM macro startaddr,endaddr
if startaddr>endaddr
fatal "Starting address of clearRAM \{startaddr} is after ending address \{endaddr}."
elseif startaddr==endaddr
warning "clearRAM is clearing zero bytes. Turning this into a nop instead."
exitm
endif
if ((startaddr)&$8000)==0
lea (startaddr).l,a1
else
lea (startaddr).w,a1
endif
moveq #0,d0
if ((startaddr)&1)
move.b d0,(a1)+
endif
move.w #bytesToLcnt((endaddr-startaddr) - ((startaddr)&1)),d1
.loop: move.l d0,(a1)+
dbf d1,.loop
if (((endaddr-startaddr) - ((startaddr)&1))&2)
move.w d0,(a1)+
endif
if (((endaddr-startaddr) - ((startaddr)&1))&1)
move.b d0,(a1)+
endif
endm
; tells the Z80 to stop, and waits for it to finish stopping (acquire bus)
stopZ80 macro
move.w #$100,(Z80_Bus_Request).l ; stop the Z80
.loop: btst #0,(Z80_Bus_Request).l
bne.s .loop ; loop until it says it's stopped
endm
; tells the Z80 to start again
startZ80 macro
move.w #0,(Z80_Bus_Request).l ; start the Z80
endm
; function to make a little-endian 16-bit pointer for the Z80 sound driver
z80_ptr function x,(x)<<8&$FF00|(x)>>8&$7F|$80
; macro to declare a little-endian 16-bit pointer for the Z80 sound driver
rom_ptr_z80 macro addr
dc.w z80_ptr(addr)
endm
; aligns the start of a bank, and detects when the bank's contents is too large
; can also print the amount of free space in a bank with DebugSoundbanks set
startBank macro {INTLABEL}
align $8000
__LABEL__ label *
soundBankStart := __LABEL__
soundBankName := "__LABEL__"
endm
DebugSoundbanks := 0
finishBank macro
if * > soundBankStart + $8000
fatal "soundBank \{soundBankName} must fit in $8000 bytes but was $\{*-soundBankStart}. Try moving something to the other bank."
elseif (DebugSoundbanks<>0)&&(MOMPASS=1)
message "soundBank \{soundBankName} has $\{$8000+soundBankStart-*} bytes free at end."
endif
endm
; macro to replace the destination with its absolute value
abs macro destination
tst.ATTRIBUTE destination
bpl.s .skip
neg.ATTRIBUTE destination
.skip:
endm
if 0|allOptimizations
absw macro destination ; use a short branch instead
abs.ATTRIBUTE destination
endm
else
; macro to replace the destination with its absolute value using a word-sized branch
absw macro destination
tst.ATTRIBUTE destination
bpl.w .skip
neg.ATTRIBUTE destination
.skip:
endm
endif
; macro to move the absolute value of the source in the destination
mvabs macro source,destination
move.ATTRIBUTE source,destination
bpl.s .skip
neg.ATTRIBUTE destination
.skip:
endm
; macro to declare an offset table
offsetTable macro {INTLABEL}
current_offset_table := __LABEL__
__LABEL__ label *
endm
; macro to declare an entry in an offset table
offsetTableEntry macro ptr
dc.ATTRIBUTE ptr-current_offset_table
endm
; macro to declare a zone-ordered table
; entryLen is the length of each table entry, and zoneEntries is the number of entries per zone
zoneOrderedTable macro entryLen,zoneEntries,{INTLABEL}
__LABEL__ label *
; set some global variables
zone_table_name := "__LABEL__"
zone_table_addr := *
zone_entry_len := entryLen
zone_entries := zoneEntries
zone_entries_left := 0
cur_zone_id := 0
cur_zone_str := "0"
endm
zoneOrderedOffsetTable macro entryLen,zoneEntries,{INTLABEL}
current_offset_table := __LABEL__
__LABEL__ zoneOrderedTable entryLen,zoneEntries
endm
; macro to declare one or more entries in a zone-ordered table
zoneTableEntry macro value
if "value"<>""
if zone_entries_left
dc.ATTRIBUTE value
zone_entries_left := zone_entries_left-1
else
!org zone_table_addr+zone_id_{cur_zone_str}*zone_entry_len*zone_entries
dc.ATTRIBUTE value
zone_entries_left := zone_entries-1
cur_zone_id := cur_zone_id+1
cur_zone_str := "\{cur_zone_id}"
endif
shift
zoneTableEntry.ATTRIBUTE ALLARGS
endif
endm
; macro to declare one or more BINCLUDE entries in a zone-ordered table
zoneTableBinEntry macro numEntries,path
if zone_entries_left
BINCLUDE path
zone_entries_left := zone_entries_left-numEntries
else
!org zone_table_addr+zone_id_{cur_zone_str}*zone_entry_len*zone_entries
BINCLUDE path
zone_entries_left := zone_entries-numEntries
cur_zone_id := cur_zone_id+1
cur_zone_str := "\{cur_zone_id}"
endif
endm
; macro to declare one entry in a zone-ordered offset table
zoneOffsetTableEntry macro value
zoneTableEntry.ATTRIBUTE value-current_offset_table
endm
; macro which sets the PC to the correct value at the end of a zone offset table and checks if the correct
; number of entries were declared
zoneTableEnd macro
if (cur_zone_id<>no_of_zones)&&(MOMPASS=1)
message "Warning: Table \{zone_table_name} has \{cur_zone_id/1.0} entries, but it should have \{(no_of_zones)/1.0} entries"
endif
!org zone_table_addr+cur_zone_id*zone_entry_len*zone_entries
endm
; macro to declare sub-object data
subObjData macro mappings,vram,renderflags,priority,width,collision
dc.l mappings
dc.w vram
dc.b renderflags,priority,width,collision
endm
; macros for defining animated PLC script lists
zoneanimstart macro {INTLABEL}
__LABEL__ label *
zoneanimcount := 0
zoneanimcur := "__LABEL__"
dc.w zoneanimcount___LABEL__ ; Number of scripts for a zone (-1)
endm
zoneanimend macro
zoneanimcount_{"\{zoneanimcur}"} = zoneanimcount-1
endm
zoneanimdeclanonid := 0
zoneanimdecl macro duration,artaddr,vramaddr,numentries,numvramtiles
zoneanimdeclanonid := zoneanimdeclanonid + 1
start:
dc.l (duration&$FF)<<24|artaddr
dc.w tiles_to_bytes(vramaddr)
dc.b numentries, numvramtiles
zoneanimcount := zoneanimcount + 1
endm
locVRAM: macro loc,controlport
if ("controlport"=="")
move.l #($40000000+((loc&$3FFF)<<16)+((loc&$C000)>>14)),(VDP_control_port).l
else
move.l #($40000000+((loc&$3FFF)<<16)+((loc&$C000)>>14)),controlport
endif
endm
; macros to convert from tile index to art tiles, block mapping or VRAM address.
make_art_tile function addr,pal,pri,((pri&1)<<15)|((pal&3)<<13)|(addr&tile_mask)
make_art_tile_2p function addr,pal,pri,((pri&1)<<15)|((pal&3)<<13)|((addr&tile_mask)>>1)
make_block_tile function addr,flx,fly,pal,pri,((pri&1)<<15)|((pal&3)<<13)|((fly&1)<<12)|((flx&1)<<11)|(addr&tile_mask)
make_block_tile_2p function addr,flx,fly,pal,pri,((pri&1)<<15)|((pal&3)<<13)|((fly&1)<<12)|((flx&1)<<11)|((addr&tile_mask)>>1)
tiles_to_bytes function addr,((addr&$7FF)<<5)
make_block_tile_pair function addr,flx,fly,pal,pri,((make_block_tile(addr,flx,fly,pal,pri)<<16)|make_block_tile(addr,flx,fly,pal,pri))
make_block_tile_pair_2p function addr,flx,fly,pal,pri,((make_block_tile_2p(addr,flx,fly,pal,pri)<<16)|make_block_tile_2p(addr,flx,fly,pal,pri))
; function to calculate the location of a tile in plane mappings with a width of 64 cells
planeLocH40 function col,line,(($80 * line) + (2 * col))
; function to calculate the location of a tile in plane mappings with a width of 128 cells
planeLocH80 function col,line,(($100 * line) + (2 * col))
SonicMappingsVer = 2
include "SpritePiece.asm"
|
;--------------------------------------------------------
; File Created by SDCC : free open source ANSI-C Compiler
; Version 3.6.0 #9615 (MINGW64)
;--------------------------------------------------------
.module lab3compass
.optsdcc -mmcs51 --model-small
;--------------------------------------------------------
; Public variables in this module
;--------------------------------------------------------
.globl _main
.globl _read_keypad
.globl _strlen
.globl _putchar
.globl _vsprintf
.globl _printf
.globl _getchar_nw
.globl _Sys_Init
.globl _UART0_Init
.globl _SYSCLK_Init
.globl _BUS_SCL
.globl _BUS_TOE
.globl _BUS_FTE
.globl _BUS_AA
.globl _BUS_INT
.globl _BUS_STOP
.globl _BUS_START
.globl _BUS_EN
.globl _BUS_BUSY
.globl _SPIF
.globl _WCOL
.globl _MODF
.globl _RXOVRN
.globl _TXBSY
.globl _SLVSEL
.globl _MSTEN
.globl _SPIEN
.globl _AD0EN
.globl _ADCEN
.globl _AD0TM
.globl _ADCTM
.globl _AD0INT
.globl _ADCINT
.globl _AD0BUSY
.globl _ADBUSY
.globl _AD0CM1
.globl _ADSTM1
.globl _AD0CM0
.globl _ADSTM0
.globl _AD0WINT
.globl _ADWINT
.globl _AD0LJST
.globl _ADLJST
.globl _CF
.globl _CR
.globl _CCF4
.globl _CCF3
.globl _CCF2
.globl _CCF1
.globl _CCF0
.globl _CY
.globl _AC
.globl _F0
.globl _RS1
.globl _RS0
.globl _OV
.globl _F1
.globl _P
.globl _TF2
.globl _EXF2
.globl _RCLK
.globl _TCLK
.globl _EXEN2
.globl _TR2
.globl _CT2
.globl _CPRL2
.globl _BUSY
.globl _ENSMB
.globl _STA
.globl _STO
.globl _SI
.globl _AA
.globl _SMBFTE
.globl _SMBTOE
.globl _PT2
.globl _PS
.globl _PS0
.globl _PT1
.globl _PX1
.globl _PT0
.globl _PX0
.globl _P3_7
.globl _P3_6
.globl _P3_5
.globl _P3_4
.globl _P3_3
.globl _P3_2
.globl _P3_1
.globl _P3_0
.globl _EA
.globl _ET2
.globl _ES
.globl _ES0
.globl _ET1
.globl _EX1
.globl _ET0
.globl _EX0
.globl _P2_7
.globl _P2_6
.globl _P2_5
.globl _P2_4
.globl _P2_3
.globl _P2_2
.globl _P2_1
.globl _P2_0
.globl _S0MODE
.globl _SM00
.globl _SM0
.globl _SM10
.globl _SM1
.globl _MCE0
.globl _SM20
.globl _SM2
.globl _REN0
.globl _REN
.globl _TB80
.globl _TB8
.globl _RB80
.globl _RB8
.globl _TI0
.globl _TI
.globl _RI0
.globl _RI
.globl _P1_7
.globl _P1_6
.globl _P1_5
.globl _P1_4
.globl _P1_3
.globl _P1_2
.globl _P1_1
.globl _P1_0
.globl _TF1
.globl _TR1
.globl _TF0
.globl _TR0
.globl _IE1
.globl _IT1
.globl _IE0
.globl _IT0
.globl _P0_7
.globl _P0_6
.globl _P0_5
.globl _P0_4
.globl _P0_3
.globl _P0_2
.globl _P0_1
.globl _P0_0
.globl _PCA0CP4
.globl _PCA0CP3
.globl _PCA0CP2
.globl _PCA0CP1
.globl _PCA0CP0
.globl _PCA0
.globl _DAC1
.globl _DAC0
.globl _ADC0LT
.globl _ADC0GT
.globl _ADC0
.globl _RCAP4
.globl _TMR4
.globl _TMR3RL
.globl _TMR3
.globl _RCAP2
.globl _TMR2
.globl _TMR1
.globl _TMR0
.globl _WDTCN
.globl _PCA0CPH4
.globl _PCA0CPH3
.globl _PCA0CPH2
.globl _PCA0CPH1
.globl _PCA0CPH0
.globl _PCA0H
.globl _SPI0CN
.globl _EIP2
.globl _EIP1
.globl _TH4
.globl _TL4
.globl _SADDR1
.globl _SBUF1
.globl _SCON1
.globl _B
.globl _RSTSRC
.globl _PCA0CPL4
.globl _PCA0CPL3
.globl _PCA0CPL2
.globl _PCA0CPL1
.globl _PCA0CPL0
.globl _PCA0L
.globl _ADC0CN
.globl _EIE2
.globl _EIE1
.globl _RCAP4H
.globl _RCAP4L
.globl _XBR2
.globl _XBR1
.globl _XBR0
.globl _ACC
.globl _PCA0CPM4
.globl _PCA0CPM3
.globl _PCA0CPM2
.globl _PCA0CPM1
.globl _PCA0CPM0
.globl _PCA0MD
.globl _PCA0CN
.globl _DAC1CN
.globl _DAC1H
.globl _DAC1L
.globl _DAC0CN
.globl _DAC0H
.globl _DAC0L
.globl _REF0CN
.globl _PSW
.globl _SMB0CR
.globl _TH2
.globl _TL2
.globl _RCAP2H
.globl _RCAP2L
.globl _T4CON
.globl _T2CON
.globl _ADC0LTH
.globl _ADC0LTL
.globl _ADC0GTH
.globl _ADC0GTL
.globl _SMB0ADR
.globl _SMB0DAT
.globl _SMB0STA
.globl _SMB0CN
.globl _ADC0H
.globl _ADC0L
.globl _P1MDIN
.globl _ADC0CF
.globl _AMX0SL
.globl _AMX0CF
.globl _SADEN0
.globl _IP
.globl _FLACL
.globl _FLSCL
.globl _P74OUT
.globl _OSCICN
.globl _OSCXCN
.globl _P3
.globl __XPAGE
.globl _EMI0CN
.globl _SADEN1
.globl _P3IF
.globl _AMX1SL
.globl _ADC1CF
.globl _ADC1CN
.globl _SADDR0
.globl _IE
.globl _P3MDOUT
.globl _PRT3CF
.globl _P2MDOUT
.globl _PRT2CF
.globl _P1MDOUT
.globl _PRT1CF
.globl _P0MDOUT
.globl _PRT0CF
.globl _EMI0CF
.globl _EMI0TC
.globl _P2
.globl _CPT1CN
.globl _CPT0CN
.globl _SPI0CKR
.globl _ADC1
.globl _SPI0DAT
.globl _SPI0CFG
.globl _SBUF0
.globl _SBUF
.globl _SCON0
.globl _SCON
.globl _P7
.globl _TMR3H
.globl _TMR3L
.globl _TMR3RLH
.globl _TMR3RLL
.globl _TMR3CN
.globl _P1
.globl _PSCTL
.globl _CKCON
.globl _TH1
.globl _TH0
.globl _TL1
.globl _TL0
.globl _TMOD
.globl _TCON
.globl _PCON
.globl _P6
.globl _P5
.globl _P4
.globl _DPH
.globl _DPL
.globl _SP
.globl _P0
.globl _input
.globl _print_count
.globl _count
.globl _reading
.globl _PCA_start
.globl _i2c_read_data_PARM_4
.globl _i2c_read_data_PARM_3
.globl _i2c_read_data_PARM_2
.globl _i2c_write_data_PARM_4
.globl _i2c_write_data_PARM_3
.globl _i2c_write_data_PARM_2
.globl _aligned_alloc_PARM_2
.globl _Data2
.globl _lcd_print
.globl _lcd_clear
.globl _kpd_input
.globl _delay_time
.globl _i2c_start
.globl _i2c_write
.globl _i2c_write_and_stop
.globl _i2c_read
.globl _i2c_read_and_stop
.globl _i2c_write_data
.globl _i2c_read_data
.globl _Accel_Init
.globl _Accel_Init_C
.globl _Port_Init
.globl _XBR0_Init
.globl _SMB_Init
.globl _PCA_Init
.globl _Interrupt_Init
.globl _PCA_ISR
.globl _Read_Compass
;--------------------------------------------------------
; special function registers
;--------------------------------------------------------
.area RSEG (ABS,DATA)
.org 0x0000
G$P0$0$0 == 0x0080
_P0 = 0x0080
G$SP$0$0 == 0x0081
_SP = 0x0081
G$DPL$0$0 == 0x0082
_DPL = 0x0082
G$DPH$0$0 == 0x0083
_DPH = 0x0083
G$P4$0$0 == 0x0084
_P4 = 0x0084
G$P5$0$0 == 0x0085
_P5 = 0x0085
G$P6$0$0 == 0x0086
_P6 = 0x0086
G$PCON$0$0 == 0x0087
_PCON = 0x0087
G$TCON$0$0 == 0x0088
_TCON = 0x0088
G$TMOD$0$0 == 0x0089
_TMOD = 0x0089
G$TL0$0$0 == 0x008a
_TL0 = 0x008a
G$TL1$0$0 == 0x008b
_TL1 = 0x008b
G$TH0$0$0 == 0x008c
_TH0 = 0x008c
G$TH1$0$0 == 0x008d
_TH1 = 0x008d
G$CKCON$0$0 == 0x008e
_CKCON = 0x008e
G$PSCTL$0$0 == 0x008f
_PSCTL = 0x008f
G$P1$0$0 == 0x0090
_P1 = 0x0090
G$TMR3CN$0$0 == 0x0091
_TMR3CN = 0x0091
G$TMR3RLL$0$0 == 0x0092
_TMR3RLL = 0x0092
G$TMR3RLH$0$0 == 0x0093
_TMR3RLH = 0x0093
G$TMR3L$0$0 == 0x0094
_TMR3L = 0x0094
G$TMR3H$0$0 == 0x0095
_TMR3H = 0x0095
G$P7$0$0 == 0x0096
_P7 = 0x0096
G$SCON$0$0 == 0x0098
_SCON = 0x0098
G$SCON0$0$0 == 0x0098
_SCON0 = 0x0098
G$SBUF$0$0 == 0x0099
_SBUF = 0x0099
G$SBUF0$0$0 == 0x0099
_SBUF0 = 0x0099
G$SPI0CFG$0$0 == 0x009a
_SPI0CFG = 0x009a
G$SPI0DAT$0$0 == 0x009b
_SPI0DAT = 0x009b
G$ADC1$0$0 == 0x009c
_ADC1 = 0x009c
G$SPI0CKR$0$0 == 0x009d
_SPI0CKR = 0x009d
G$CPT0CN$0$0 == 0x009e
_CPT0CN = 0x009e
G$CPT1CN$0$0 == 0x009f
_CPT1CN = 0x009f
G$P2$0$0 == 0x00a0
_P2 = 0x00a0
G$EMI0TC$0$0 == 0x00a1
_EMI0TC = 0x00a1
G$EMI0CF$0$0 == 0x00a3
_EMI0CF = 0x00a3
G$PRT0CF$0$0 == 0x00a4
_PRT0CF = 0x00a4
G$P0MDOUT$0$0 == 0x00a4
_P0MDOUT = 0x00a4
G$PRT1CF$0$0 == 0x00a5
_PRT1CF = 0x00a5
G$P1MDOUT$0$0 == 0x00a5
_P1MDOUT = 0x00a5
G$PRT2CF$0$0 == 0x00a6
_PRT2CF = 0x00a6
G$P2MDOUT$0$0 == 0x00a6
_P2MDOUT = 0x00a6
G$PRT3CF$0$0 == 0x00a7
_PRT3CF = 0x00a7
G$P3MDOUT$0$0 == 0x00a7
_P3MDOUT = 0x00a7
G$IE$0$0 == 0x00a8
_IE = 0x00a8
G$SADDR0$0$0 == 0x00a9
_SADDR0 = 0x00a9
G$ADC1CN$0$0 == 0x00aa
_ADC1CN = 0x00aa
G$ADC1CF$0$0 == 0x00ab
_ADC1CF = 0x00ab
G$AMX1SL$0$0 == 0x00ac
_AMX1SL = 0x00ac
G$P3IF$0$0 == 0x00ad
_P3IF = 0x00ad
G$SADEN1$0$0 == 0x00ae
_SADEN1 = 0x00ae
G$EMI0CN$0$0 == 0x00af
_EMI0CN = 0x00af
G$_XPAGE$0$0 == 0x00af
__XPAGE = 0x00af
G$P3$0$0 == 0x00b0
_P3 = 0x00b0
G$OSCXCN$0$0 == 0x00b1
_OSCXCN = 0x00b1
G$OSCICN$0$0 == 0x00b2
_OSCICN = 0x00b2
G$P74OUT$0$0 == 0x00b5
_P74OUT = 0x00b5
G$FLSCL$0$0 == 0x00b6
_FLSCL = 0x00b6
G$FLACL$0$0 == 0x00b7
_FLACL = 0x00b7
G$IP$0$0 == 0x00b8
_IP = 0x00b8
G$SADEN0$0$0 == 0x00b9
_SADEN0 = 0x00b9
G$AMX0CF$0$0 == 0x00ba
_AMX0CF = 0x00ba
G$AMX0SL$0$0 == 0x00bb
_AMX0SL = 0x00bb
G$ADC0CF$0$0 == 0x00bc
_ADC0CF = 0x00bc
G$P1MDIN$0$0 == 0x00bd
_P1MDIN = 0x00bd
G$ADC0L$0$0 == 0x00be
_ADC0L = 0x00be
G$ADC0H$0$0 == 0x00bf
_ADC0H = 0x00bf
G$SMB0CN$0$0 == 0x00c0
_SMB0CN = 0x00c0
G$SMB0STA$0$0 == 0x00c1
_SMB0STA = 0x00c1
G$SMB0DAT$0$0 == 0x00c2
_SMB0DAT = 0x00c2
G$SMB0ADR$0$0 == 0x00c3
_SMB0ADR = 0x00c3
G$ADC0GTL$0$0 == 0x00c4
_ADC0GTL = 0x00c4
G$ADC0GTH$0$0 == 0x00c5
_ADC0GTH = 0x00c5
G$ADC0LTL$0$0 == 0x00c6
_ADC0LTL = 0x00c6
G$ADC0LTH$0$0 == 0x00c7
_ADC0LTH = 0x00c7
G$T2CON$0$0 == 0x00c8
_T2CON = 0x00c8
G$T4CON$0$0 == 0x00c9
_T4CON = 0x00c9
G$RCAP2L$0$0 == 0x00ca
_RCAP2L = 0x00ca
G$RCAP2H$0$0 == 0x00cb
_RCAP2H = 0x00cb
G$TL2$0$0 == 0x00cc
_TL2 = 0x00cc
G$TH2$0$0 == 0x00cd
_TH2 = 0x00cd
G$SMB0CR$0$0 == 0x00cf
_SMB0CR = 0x00cf
G$PSW$0$0 == 0x00d0
_PSW = 0x00d0
G$REF0CN$0$0 == 0x00d1
_REF0CN = 0x00d1
G$DAC0L$0$0 == 0x00d2
_DAC0L = 0x00d2
G$DAC0H$0$0 == 0x00d3
_DAC0H = 0x00d3
G$DAC0CN$0$0 == 0x00d4
_DAC0CN = 0x00d4
G$DAC1L$0$0 == 0x00d5
_DAC1L = 0x00d5
G$DAC1H$0$0 == 0x00d6
_DAC1H = 0x00d6
G$DAC1CN$0$0 == 0x00d7
_DAC1CN = 0x00d7
G$PCA0CN$0$0 == 0x00d8
_PCA0CN = 0x00d8
G$PCA0MD$0$0 == 0x00d9
_PCA0MD = 0x00d9
G$PCA0CPM0$0$0 == 0x00da
_PCA0CPM0 = 0x00da
G$PCA0CPM1$0$0 == 0x00db
_PCA0CPM1 = 0x00db
G$PCA0CPM2$0$0 == 0x00dc
_PCA0CPM2 = 0x00dc
G$PCA0CPM3$0$0 == 0x00dd
_PCA0CPM3 = 0x00dd
G$PCA0CPM4$0$0 == 0x00de
_PCA0CPM4 = 0x00de
G$ACC$0$0 == 0x00e0
_ACC = 0x00e0
G$XBR0$0$0 == 0x00e1
_XBR0 = 0x00e1
G$XBR1$0$0 == 0x00e2
_XBR1 = 0x00e2
G$XBR2$0$0 == 0x00e3
_XBR2 = 0x00e3
G$RCAP4L$0$0 == 0x00e4
_RCAP4L = 0x00e4
G$RCAP4H$0$0 == 0x00e5
_RCAP4H = 0x00e5
G$EIE1$0$0 == 0x00e6
_EIE1 = 0x00e6
G$EIE2$0$0 == 0x00e7
_EIE2 = 0x00e7
G$ADC0CN$0$0 == 0x00e8
_ADC0CN = 0x00e8
G$PCA0L$0$0 == 0x00e9
_PCA0L = 0x00e9
G$PCA0CPL0$0$0 == 0x00ea
_PCA0CPL0 = 0x00ea
G$PCA0CPL1$0$0 == 0x00eb
_PCA0CPL1 = 0x00eb
G$PCA0CPL2$0$0 == 0x00ec
_PCA0CPL2 = 0x00ec
G$PCA0CPL3$0$0 == 0x00ed
_PCA0CPL3 = 0x00ed
G$PCA0CPL4$0$0 == 0x00ee
_PCA0CPL4 = 0x00ee
G$RSTSRC$0$0 == 0x00ef
_RSTSRC = 0x00ef
G$B$0$0 == 0x00f0
_B = 0x00f0
G$SCON1$0$0 == 0x00f1
_SCON1 = 0x00f1
G$SBUF1$0$0 == 0x00f2
_SBUF1 = 0x00f2
G$SADDR1$0$0 == 0x00f3
_SADDR1 = 0x00f3
G$TL4$0$0 == 0x00f4
_TL4 = 0x00f4
G$TH4$0$0 == 0x00f5
_TH4 = 0x00f5
G$EIP1$0$0 == 0x00f6
_EIP1 = 0x00f6
G$EIP2$0$0 == 0x00f7
_EIP2 = 0x00f7
G$SPI0CN$0$0 == 0x00f8
_SPI0CN = 0x00f8
G$PCA0H$0$0 == 0x00f9
_PCA0H = 0x00f9
G$PCA0CPH0$0$0 == 0x00fa
_PCA0CPH0 = 0x00fa
G$PCA0CPH1$0$0 == 0x00fb
_PCA0CPH1 = 0x00fb
G$PCA0CPH2$0$0 == 0x00fc
_PCA0CPH2 = 0x00fc
G$PCA0CPH3$0$0 == 0x00fd
_PCA0CPH3 = 0x00fd
G$PCA0CPH4$0$0 == 0x00fe
_PCA0CPH4 = 0x00fe
G$WDTCN$0$0 == 0x00ff
_WDTCN = 0x00ff
G$TMR0$0$0 == 0x8c8a
_TMR0 = 0x8c8a
G$TMR1$0$0 == 0x8d8b
_TMR1 = 0x8d8b
G$TMR2$0$0 == 0xcdcc
_TMR2 = 0xcdcc
G$RCAP2$0$0 == 0xcbca
_RCAP2 = 0xcbca
G$TMR3$0$0 == 0x9594
_TMR3 = 0x9594
G$TMR3RL$0$0 == 0x9392
_TMR3RL = 0x9392
G$TMR4$0$0 == 0xf5f4
_TMR4 = 0xf5f4
G$RCAP4$0$0 == 0xe5e4
_RCAP4 = 0xe5e4
G$ADC0$0$0 == 0xbfbe
_ADC0 = 0xbfbe
G$ADC0GT$0$0 == 0xc5c4
_ADC0GT = 0xc5c4
G$ADC0LT$0$0 == 0xc7c6
_ADC0LT = 0xc7c6
G$DAC0$0$0 == 0xd3d2
_DAC0 = 0xd3d2
G$DAC1$0$0 == 0xd6d5
_DAC1 = 0xd6d5
G$PCA0$0$0 == 0xf9e9
_PCA0 = 0xf9e9
G$PCA0CP0$0$0 == 0xfaea
_PCA0CP0 = 0xfaea
G$PCA0CP1$0$0 == 0xfbeb
_PCA0CP1 = 0xfbeb
G$PCA0CP2$0$0 == 0xfcec
_PCA0CP2 = 0xfcec
G$PCA0CP3$0$0 == 0xfded
_PCA0CP3 = 0xfded
G$PCA0CP4$0$0 == 0xfeee
_PCA0CP4 = 0xfeee
;--------------------------------------------------------
; special function bits
;--------------------------------------------------------
.area RSEG (ABS,DATA)
.org 0x0000
G$P0_0$0$0 == 0x0080
_P0_0 = 0x0080
G$P0_1$0$0 == 0x0081
_P0_1 = 0x0081
G$P0_2$0$0 == 0x0082
_P0_2 = 0x0082
G$P0_3$0$0 == 0x0083
_P0_3 = 0x0083
G$P0_4$0$0 == 0x0084
_P0_4 = 0x0084
G$P0_5$0$0 == 0x0085
_P0_5 = 0x0085
G$P0_6$0$0 == 0x0086
_P0_6 = 0x0086
G$P0_7$0$0 == 0x0087
_P0_7 = 0x0087
G$IT0$0$0 == 0x0088
_IT0 = 0x0088
G$IE0$0$0 == 0x0089
_IE0 = 0x0089
G$IT1$0$0 == 0x008a
_IT1 = 0x008a
G$IE1$0$0 == 0x008b
_IE1 = 0x008b
G$TR0$0$0 == 0x008c
_TR0 = 0x008c
G$TF0$0$0 == 0x008d
_TF0 = 0x008d
G$TR1$0$0 == 0x008e
_TR1 = 0x008e
G$TF1$0$0 == 0x008f
_TF1 = 0x008f
G$P1_0$0$0 == 0x0090
_P1_0 = 0x0090
G$P1_1$0$0 == 0x0091
_P1_1 = 0x0091
G$P1_2$0$0 == 0x0092
_P1_2 = 0x0092
G$P1_3$0$0 == 0x0093
_P1_3 = 0x0093
G$P1_4$0$0 == 0x0094
_P1_4 = 0x0094
G$P1_5$0$0 == 0x0095
_P1_5 = 0x0095
G$P1_6$0$0 == 0x0096
_P1_6 = 0x0096
G$P1_7$0$0 == 0x0097
_P1_7 = 0x0097
G$RI$0$0 == 0x0098
_RI = 0x0098
G$RI0$0$0 == 0x0098
_RI0 = 0x0098
G$TI$0$0 == 0x0099
_TI = 0x0099
G$TI0$0$0 == 0x0099
_TI0 = 0x0099
G$RB8$0$0 == 0x009a
_RB8 = 0x009a
G$RB80$0$0 == 0x009a
_RB80 = 0x009a
G$TB8$0$0 == 0x009b
_TB8 = 0x009b
G$TB80$0$0 == 0x009b
_TB80 = 0x009b
G$REN$0$0 == 0x009c
_REN = 0x009c
G$REN0$0$0 == 0x009c
_REN0 = 0x009c
G$SM2$0$0 == 0x009d
_SM2 = 0x009d
G$SM20$0$0 == 0x009d
_SM20 = 0x009d
G$MCE0$0$0 == 0x009d
_MCE0 = 0x009d
G$SM1$0$0 == 0x009e
_SM1 = 0x009e
G$SM10$0$0 == 0x009e
_SM10 = 0x009e
G$SM0$0$0 == 0x009f
_SM0 = 0x009f
G$SM00$0$0 == 0x009f
_SM00 = 0x009f
G$S0MODE$0$0 == 0x009f
_S0MODE = 0x009f
G$P2_0$0$0 == 0x00a0
_P2_0 = 0x00a0
G$P2_1$0$0 == 0x00a1
_P2_1 = 0x00a1
G$P2_2$0$0 == 0x00a2
_P2_2 = 0x00a2
G$P2_3$0$0 == 0x00a3
_P2_3 = 0x00a3
G$P2_4$0$0 == 0x00a4
_P2_4 = 0x00a4
G$P2_5$0$0 == 0x00a5
_P2_5 = 0x00a5
G$P2_6$0$0 == 0x00a6
_P2_6 = 0x00a6
G$P2_7$0$0 == 0x00a7
_P2_7 = 0x00a7
G$EX0$0$0 == 0x00a8
_EX0 = 0x00a8
G$ET0$0$0 == 0x00a9
_ET0 = 0x00a9
G$EX1$0$0 == 0x00aa
_EX1 = 0x00aa
G$ET1$0$0 == 0x00ab
_ET1 = 0x00ab
G$ES0$0$0 == 0x00ac
_ES0 = 0x00ac
G$ES$0$0 == 0x00ac
_ES = 0x00ac
G$ET2$0$0 == 0x00ad
_ET2 = 0x00ad
G$EA$0$0 == 0x00af
_EA = 0x00af
G$P3_0$0$0 == 0x00b0
_P3_0 = 0x00b0
G$P3_1$0$0 == 0x00b1
_P3_1 = 0x00b1
G$P3_2$0$0 == 0x00b2
_P3_2 = 0x00b2
G$P3_3$0$0 == 0x00b3
_P3_3 = 0x00b3
G$P3_4$0$0 == 0x00b4
_P3_4 = 0x00b4
G$P3_5$0$0 == 0x00b5
_P3_5 = 0x00b5
G$P3_6$0$0 == 0x00b6
_P3_6 = 0x00b6
G$P3_7$0$0 == 0x00b7
_P3_7 = 0x00b7
G$PX0$0$0 == 0x00b8
_PX0 = 0x00b8
G$PT0$0$0 == 0x00b9
_PT0 = 0x00b9
G$PX1$0$0 == 0x00ba
_PX1 = 0x00ba
G$PT1$0$0 == 0x00bb
_PT1 = 0x00bb
G$PS0$0$0 == 0x00bc
_PS0 = 0x00bc
G$PS$0$0 == 0x00bc
_PS = 0x00bc
G$PT2$0$0 == 0x00bd
_PT2 = 0x00bd
G$SMBTOE$0$0 == 0x00c0
_SMBTOE = 0x00c0
G$SMBFTE$0$0 == 0x00c1
_SMBFTE = 0x00c1
G$AA$0$0 == 0x00c2
_AA = 0x00c2
G$SI$0$0 == 0x00c3
_SI = 0x00c3
G$STO$0$0 == 0x00c4
_STO = 0x00c4
G$STA$0$0 == 0x00c5
_STA = 0x00c5
G$ENSMB$0$0 == 0x00c6
_ENSMB = 0x00c6
G$BUSY$0$0 == 0x00c7
_BUSY = 0x00c7
G$CPRL2$0$0 == 0x00c8
_CPRL2 = 0x00c8
G$CT2$0$0 == 0x00c9
_CT2 = 0x00c9
G$TR2$0$0 == 0x00ca
_TR2 = 0x00ca
G$EXEN2$0$0 == 0x00cb
_EXEN2 = 0x00cb
G$TCLK$0$0 == 0x00cc
_TCLK = 0x00cc
G$RCLK$0$0 == 0x00cd
_RCLK = 0x00cd
G$EXF2$0$0 == 0x00ce
_EXF2 = 0x00ce
G$TF2$0$0 == 0x00cf
_TF2 = 0x00cf
G$P$0$0 == 0x00d0
_P = 0x00d0
G$F1$0$0 == 0x00d1
_F1 = 0x00d1
G$OV$0$0 == 0x00d2
_OV = 0x00d2
G$RS0$0$0 == 0x00d3
_RS0 = 0x00d3
G$RS1$0$0 == 0x00d4
_RS1 = 0x00d4
G$F0$0$0 == 0x00d5
_F0 = 0x00d5
G$AC$0$0 == 0x00d6
_AC = 0x00d6
G$CY$0$0 == 0x00d7
_CY = 0x00d7
G$CCF0$0$0 == 0x00d8
_CCF0 = 0x00d8
G$CCF1$0$0 == 0x00d9
_CCF1 = 0x00d9
G$CCF2$0$0 == 0x00da
_CCF2 = 0x00da
G$CCF3$0$0 == 0x00db
_CCF3 = 0x00db
G$CCF4$0$0 == 0x00dc
_CCF4 = 0x00dc
G$CR$0$0 == 0x00de
_CR = 0x00de
G$CF$0$0 == 0x00df
_CF = 0x00df
G$ADLJST$0$0 == 0x00e8
_ADLJST = 0x00e8
G$AD0LJST$0$0 == 0x00e8
_AD0LJST = 0x00e8
G$ADWINT$0$0 == 0x00e9
_ADWINT = 0x00e9
G$AD0WINT$0$0 == 0x00e9
_AD0WINT = 0x00e9
G$ADSTM0$0$0 == 0x00ea
_ADSTM0 = 0x00ea
G$AD0CM0$0$0 == 0x00ea
_AD0CM0 = 0x00ea
G$ADSTM1$0$0 == 0x00eb
_ADSTM1 = 0x00eb
G$AD0CM1$0$0 == 0x00eb
_AD0CM1 = 0x00eb
G$ADBUSY$0$0 == 0x00ec
_ADBUSY = 0x00ec
G$AD0BUSY$0$0 == 0x00ec
_AD0BUSY = 0x00ec
G$ADCINT$0$0 == 0x00ed
_ADCINT = 0x00ed
G$AD0INT$0$0 == 0x00ed
_AD0INT = 0x00ed
G$ADCTM$0$0 == 0x00ee
_ADCTM = 0x00ee
G$AD0TM$0$0 == 0x00ee
_AD0TM = 0x00ee
G$ADCEN$0$0 == 0x00ef
_ADCEN = 0x00ef
G$AD0EN$0$0 == 0x00ef
_AD0EN = 0x00ef
G$SPIEN$0$0 == 0x00f8
_SPIEN = 0x00f8
G$MSTEN$0$0 == 0x00f9
_MSTEN = 0x00f9
G$SLVSEL$0$0 == 0x00fa
_SLVSEL = 0x00fa
G$TXBSY$0$0 == 0x00fb
_TXBSY = 0x00fb
G$RXOVRN$0$0 == 0x00fc
_RXOVRN = 0x00fc
G$MODF$0$0 == 0x00fd
_MODF = 0x00fd
G$WCOL$0$0 == 0x00fe
_WCOL = 0x00fe
G$SPIF$0$0 == 0x00ff
_SPIF = 0x00ff
G$BUS_BUSY$0$0 == 0x00c7
_BUS_BUSY = 0x00c7
G$BUS_EN$0$0 == 0x00c6
_BUS_EN = 0x00c6
G$BUS_START$0$0 == 0x00c5
_BUS_START = 0x00c5
G$BUS_STOP$0$0 == 0x00c4
_BUS_STOP = 0x00c4
G$BUS_INT$0$0 == 0x00c3
_BUS_INT = 0x00c3
G$BUS_AA$0$0 == 0x00c2
_BUS_AA = 0x00c2
G$BUS_FTE$0$0 == 0x00c1
_BUS_FTE = 0x00c1
G$BUS_TOE$0$0 == 0x00c0
_BUS_TOE = 0x00c0
G$BUS_SCL$0$0 == 0x0083
_BUS_SCL = 0x0083
;--------------------------------------------------------
; overlayable register banks
;--------------------------------------------------------
.area REG_BANK_0 (REL,OVR,DATA)
.ds 8
;--------------------------------------------------------
; internal ram data
;--------------------------------------------------------
.area DSEG (DATA)
G$Data2$0$0==.
_Data2::
.ds 3
Llab3compass.aligned_alloc$size$1$39==.
_aligned_alloc_PARM_2:
.ds 2
Llab3compass.lcd_clear$NumBytes$1$85==.
_lcd_clear_NumBytes_1_85:
.ds 1
Llab3compass.lcd_clear$Cmd$1$85==.
_lcd_clear_Cmd_1_85:
.ds 2
Llab3compass.read_keypad$Data$1$86==.
_read_keypad_Data_1_86:
.ds 2
Llab3compass.i2c_write_data$start_reg$1$105==.
_i2c_write_data_PARM_2:
.ds 1
Llab3compass.i2c_write_data$buffer$1$105==.
_i2c_write_data_PARM_3:
.ds 3
Llab3compass.i2c_write_data$num_bytes$1$105==.
_i2c_write_data_PARM_4:
.ds 1
Llab3compass.i2c_read_data$start_reg$1$107==.
_i2c_read_data_PARM_2:
.ds 1
Llab3compass.i2c_read_data$buffer$1$107==.
_i2c_read_data_PARM_3:
.ds 3
Llab3compass.i2c_read_data$num_bytes$1$107==.
_i2c_read_data_PARM_4:
.ds 1
G$PCA_start$0$0==.
_PCA_start::
.ds 2
G$reading$0$0==.
_reading::
.ds 2
G$count$0$0==.
_count::
.ds 2
G$print_count$0$0==.
_print_count::
.ds 2
G$input$0$0==.
_input::
.ds 1
Llab3compass.Read_Compass$buffer$1$137==.
_Read_Compass_buffer_1_137:
.ds 2
;--------------------------------------------------------
; overlayable items in internal ram
;--------------------------------------------------------
.area OSEG (OVR,DATA)
.area OSEG (OVR,DATA)
.area OSEG (OVR,DATA)
.area OSEG (OVR,DATA)
.area OSEG (OVR,DATA)
.area OSEG (OVR,DATA)
.area OSEG (OVR,DATA)
;--------------------------------------------------------
; Stack segment in internal ram
;--------------------------------------------------------
.area SSEG
__start__stack:
.ds 1
;--------------------------------------------------------
; indirectly addressable internal ram data
;--------------------------------------------------------
.area ISEG (DATA)
;--------------------------------------------------------
; absolute internal ram data
;--------------------------------------------------------
.area IABS (ABS,DATA)
.area IABS (ABS,DATA)
;--------------------------------------------------------
; bit data
;--------------------------------------------------------
.area BSEG (BIT)
;--------------------------------------------------------
; paged external ram data
;--------------------------------------------------------
.area PSEG (PAG,XDATA)
;--------------------------------------------------------
; external ram data
;--------------------------------------------------------
.area XSEG (XDATA)
Llab3compass.lcd_print$text$1$81==.
_lcd_print_text_1_81:
.ds 80
;--------------------------------------------------------
; absolute external ram data
;--------------------------------------------------------
.area XABS (ABS,XDATA)
;--------------------------------------------------------
; external initialized ram data
;--------------------------------------------------------
.area XISEG (XDATA)
.area HOME (CODE)
.area GSINIT0 (CODE)
.area GSINIT1 (CODE)
.area GSINIT2 (CODE)
.area GSINIT3 (CODE)
.area GSINIT4 (CODE)
.area GSINIT5 (CODE)
.area GSINIT (CODE)
.area GSFINAL (CODE)
.area CSEG (CODE)
;--------------------------------------------------------
; interrupt vector
;--------------------------------------------------------
.area HOME (CODE)
__interrupt_vect:
ljmp __sdcc_gsinit_startup
reti
.ds 7
reti
.ds 7
reti
.ds 7
reti
.ds 7
reti
.ds 7
reti
.ds 7
reti
.ds 7
reti
.ds 7
reti
.ds 7
ljmp _PCA_ISR
;--------------------------------------------------------
; global & static initialisations
;--------------------------------------------------------
.area HOME (CODE)
.area GSINIT (CODE)
.area GSFINAL (CODE)
.area GSINIT (CODE)
.globl __sdcc_gsinit_startup
.globl __sdcc_program_startup
.globl __start__stack
.globl __mcs51_genXINIT
.globl __mcs51_genXRAMCLEAR
.globl __mcs51_genRAMCLEAR
C$lab3compass.c$20$1$137 ==.
; C:\SiLabs\LITEC\Lab3\lab3compass.c:20: unsigned int PCA_start = 28671;
mov _PCA_start,#0xff
mov (_PCA_start + 1),#0x6f
C$lab3compass.c$21$1$137 ==.
; C:\SiLabs\LITEC\Lab3\lab3compass.c:21: unsigned int reading=0;
clr a
mov _reading,a
mov (_reading + 1),a
C$lab3compass.c$22$1$137 ==.
; C:\SiLabs\LITEC\Lab3\lab3compass.c:22: unsigned int count = 0;
mov _count,a
mov (_count + 1),a
C$lab3compass.c$23$1$137 ==.
; C:\SiLabs\LITEC\Lab3\lab3compass.c:23: unsigned int print_count=0;
mov _print_count,a
mov (_print_count + 1),a
.area GSFINAL (CODE)
ljmp __sdcc_program_startup
;--------------------------------------------------------
; Home
;--------------------------------------------------------
.area HOME (CODE)
.area HOME (CODE)
__sdcc_program_startup:
ljmp _main
; return from main will return to caller
;--------------------------------------------------------
; code
;--------------------------------------------------------
.area CSEG (CODE)
;------------------------------------------------------------
;Allocation info for local variables in function 'SYSCLK_Init'
;------------------------------------------------------------
;i Allocated to registers r6 r7
;------------------------------------------------------------
G$SYSCLK_Init$0$0 ==.
C$c8051_SDCC.h$42$0$0 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/c8051_SDCC.h:42: void SYSCLK_Init(void)
; -----------------------------------------
; function SYSCLK_Init
; -----------------------------------------
_SYSCLK_Init:
ar7 = 0x07
ar6 = 0x06
ar5 = 0x05
ar4 = 0x04
ar3 = 0x03
ar2 = 0x02
ar1 = 0x01
ar0 = 0x00
C$c8051_SDCC.h$46$1$2 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/c8051_SDCC.h:46: OSCXCN = 0x67; // start external oscillator with
mov _OSCXCN,#0x67
C$c8051_SDCC.h$49$1$2 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/c8051_SDCC.h:49: for (i=0; i < 256; i++); // wait for oscillator to start
mov r6,#0x00
mov r7,#0x01
00107$:
mov a,r6
add a,#0xff
mov r4,a
mov a,r7
addc a,#0xff
mov r5,a
mov ar6,r4
mov ar7,r5
mov a,r4
orl a,r5
jnz 00107$
C$c8051_SDCC.h$51$1$2 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/c8051_SDCC.h:51: while (!(OSCXCN & 0x80)); // Wait for crystal osc. to settle
00102$:
mov a,_OSCXCN
jnb acc.7,00102$
C$c8051_SDCC.h$53$1$2 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/c8051_SDCC.h:53: OSCICN = 0x88; // select external oscillator as SYSCLK
mov _OSCICN,#0x88
C$c8051_SDCC.h$56$1$2 ==.
XG$SYSCLK_Init$0$0 ==.
ret
;------------------------------------------------------------
;Allocation info for local variables in function 'UART0_Init'
;------------------------------------------------------------
G$UART0_Init$0$0 ==.
C$c8051_SDCC.h$64$1$2 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/c8051_SDCC.h:64: void UART0_Init(void)
; -----------------------------------------
; function UART0_Init
; -----------------------------------------
_UART0_Init:
C$c8051_SDCC.h$66$1$4 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/c8051_SDCC.h:66: SCON0 = 0x50; // SCON0: mode 1, 8-bit UART, enable RX
mov _SCON0,#0x50
C$c8051_SDCC.h$67$1$4 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/c8051_SDCC.h:67: TMOD = 0x20; // TMOD: timer 1, mode 2, 8-bit reload
mov _TMOD,#0x20
C$c8051_SDCC.h$68$1$4 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/c8051_SDCC.h:68: TH1 = 0xFF&-(SYSCLK/BAUDRATE/16); // set Timer1 reload value for baudrate
mov _TH1,#0xdc
C$c8051_SDCC.h$69$1$4 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/c8051_SDCC.h:69: TR1 = 1; // start Timer1
setb _TR1
C$c8051_SDCC.h$70$1$4 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/c8051_SDCC.h:70: CKCON |= 0x10; // Timer1 uses SYSCLK as time base
orl _CKCON,#0x10
C$c8051_SDCC.h$71$1$4 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/c8051_SDCC.h:71: PCON |= 0x80; // SMOD00 = 1 (disable baud rate
orl _PCON,#0x80
C$c8051_SDCC.h$73$1$4 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/c8051_SDCC.h:73: TI0 = 1; // Indicate TX0 ready
setb _TI0
C$c8051_SDCC.h$74$1$4 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/c8051_SDCC.h:74: P0MDOUT |= 0x01; // Set TX0 to push/pull
orl _P0MDOUT,#0x01
C$c8051_SDCC.h$75$1$4 ==.
XG$UART0_Init$0$0 ==.
ret
;------------------------------------------------------------
;Allocation info for local variables in function 'Sys_Init'
;------------------------------------------------------------
G$Sys_Init$0$0 ==.
C$c8051_SDCC.h$83$1$4 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/c8051_SDCC.h:83: void Sys_Init(void)
; -----------------------------------------
; function Sys_Init
; -----------------------------------------
_Sys_Init:
C$c8051_SDCC.h$85$1$6 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/c8051_SDCC.h:85: WDTCN = 0xde; // disable watchdog timer
mov _WDTCN,#0xde
C$c8051_SDCC.h$86$1$6 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/c8051_SDCC.h:86: WDTCN = 0xad;
mov _WDTCN,#0xad
C$c8051_SDCC.h$88$1$6 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/c8051_SDCC.h:88: SYSCLK_Init(); // initialize oscillator
lcall _SYSCLK_Init
C$c8051_SDCC.h$89$1$6 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/c8051_SDCC.h:89: UART0_Init(); // initialize UART0
lcall _UART0_Init
C$c8051_SDCC.h$91$1$6 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/c8051_SDCC.h:91: XBR0 |= 0x04;
orl _XBR0,#0x04
C$c8051_SDCC.h$92$1$6 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/c8051_SDCC.h:92: XBR2 |= 0x40; // Enable crossbar and weak pull-ups
orl _XBR2,#0x40
C$c8051_SDCC.h$93$1$6 ==.
XG$Sys_Init$0$0 ==.
ret
;------------------------------------------------------------
;Allocation info for local variables in function 'putchar'
;------------------------------------------------------------
;c Allocated to registers r7
;------------------------------------------------------------
G$putchar$0$0 ==.
C$c8051_SDCC.h$98$1$6 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/c8051_SDCC.h:98: void putchar(char c)
; -----------------------------------------
; function putchar
; -----------------------------------------
_putchar:
mov r7,dpl
C$c8051_SDCC.h$100$1$8 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/c8051_SDCC.h:100: while (!TI0);
00101$:
C$c8051_SDCC.h$101$1$8 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/c8051_SDCC.h:101: TI0 = 0;
jbc _TI0,00112$
sjmp 00101$
00112$:
C$c8051_SDCC.h$102$1$8 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/c8051_SDCC.h:102: SBUF0 = c;
mov _SBUF0,r7
C$c8051_SDCC.h$103$1$8 ==.
XG$putchar$0$0 ==.
ret
;------------------------------------------------------------
;Allocation info for local variables in function 'getchar'
;------------------------------------------------------------
;c Allocated to registers
;------------------------------------------------------------
G$getchar$0$0 ==.
C$c8051_SDCC.h$108$1$8 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/c8051_SDCC.h:108: char getchar(void)
; -----------------------------------------
; function getchar
; -----------------------------------------
_getchar:
C$c8051_SDCC.h$111$1$10 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/c8051_SDCC.h:111: while (!RI0);
00101$:
C$c8051_SDCC.h$112$1$10 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/c8051_SDCC.h:112: RI0 = 0;
jbc _RI0,00112$
sjmp 00101$
00112$:
C$c8051_SDCC.h$113$1$10 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/c8051_SDCC.h:113: c = SBUF0;
mov dpl,_SBUF0
C$c8051_SDCC.h$114$1$10 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/c8051_SDCC.h:114: putchar(c); // echo to terminal
lcall _putchar
C$c8051_SDCC.h$115$1$10 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/c8051_SDCC.h:115: return SBUF0;
mov dpl,_SBUF0
C$c8051_SDCC.h$116$1$10 ==.
XG$getchar$0$0 ==.
ret
;------------------------------------------------------------
;Allocation info for local variables in function 'getchar_nw'
;------------------------------------------------------------
;c Allocated to registers
;------------------------------------------------------------
G$getchar_nw$0$0 ==.
C$c8051_SDCC.h$121$1$10 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/c8051_SDCC.h:121: char getchar_nw(void)
; -----------------------------------------
; function getchar_nw
; -----------------------------------------
_getchar_nw:
C$c8051_SDCC.h$124$1$12 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/c8051_SDCC.h:124: if (!RI0) return 0xFF;
jb _RI0,00102$
mov dpl,#0xff
sjmp 00104$
00102$:
C$c8051_SDCC.h$127$2$13 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/c8051_SDCC.h:127: RI0 = 0;
clr _RI0
C$c8051_SDCC.h$128$2$13 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/c8051_SDCC.h:128: c = SBUF0;
mov dpl,_SBUF0
C$c8051_SDCC.h$129$2$13 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/c8051_SDCC.h:129: putchar(c); // echo to terminal
lcall _putchar
C$c8051_SDCC.h$130$2$13 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/c8051_SDCC.h:130: return SBUF0;
mov dpl,_SBUF0
00104$:
C$c8051_SDCC.h$132$1$12 ==.
XG$getchar_nw$0$0 ==.
ret
;------------------------------------------------------------
;Allocation info for local variables in function 'lcd_print'
;------------------------------------------------------------
;fmt Allocated to stack - _bp -5
;len Allocated to registers r6
;i Allocated to registers
;ap Allocated to registers
;text Allocated with name '_lcd_print_text_1_81'
;------------------------------------------------------------
G$lcd_print$0$0 ==.
C$i2c.h$84$1$12 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:84: void lcd_print(const char *fmt, ...)
; -----------------------------------------
; function lcd_print
; -----------------------------------------
_lcd_print:
push _bp
mov _bp,sp
C$i2c.h$90$1$81 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:90: if ( strlen(fmt) <= 0 ) return; //If there is no data to print, return
mov a,_bp
add a,#0xfb
mov r0,a
mov dpl,@r0
inc r0
mov dph,@r0
inc r0
mov b,@r0
lcall _strlen
mov a,dpl
mov b,dph
orl a,b
jnz 00102$
sjmp 00109$
00102$:
C$i2c.h$92$2$82 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:92: va_start(ap, fmt);
mov a,_bp
add a,#0xfb
mov r7,a
mov _vsprintf_PARM_3,r7
C$i2c.h$93$1$81 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:93: vsprintf(text, fmt, ap);
mov a,_bp
add a,#0xfb
mov r0,a
mov _vsprintf_PARM_2,@r0
inc r0
mov (_vsprintf_PARM_2 + 1),@r0
inc r0
mov (_vsprintf_PARM_2 + 2),@r0
mov dptr,#_lcd_print_text_1_81
mov b,#0x00
lcall _vsprintf
C$i2c.h$96$1$81 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:96: len = strlen(text);
mov dptr,#_lcd_print_text_1_81
mov b,#0x00
lcall _strlen
mov r6,dpl
C$i2c.h$97$1$81 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:97: for(i=0; i<len; i++)
mov r7,#0x00
00107$:
clr c
mov a,r7
subb a,r6
jnc 00105$
C$i2c.h$99$2$84 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:99: if(text[i] == (unsigned char)'\n') text[i] = 13;
mov a,r7
add a,#_lcd_print_text_1_81
mov dpl,a
clr a
addc a,#(_lcd_print_text_1_81 >> 8)
mov dph,a
movx a,@dptr
mov r5,a
cjne r5,#0x0a,00108$
mov a,r7
add a,#_lcd_print_text_1_81
mov dpl,a
clr a
addc a,#(_lcd_print_text_1_81 >> 8)
mov dph,a
mov a,#0x0d
movx @dptr,a
00108$:
C$i2c.h$97$1$81 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:97: for(i=0; i<len; i++)
inc r7
sjmp 00107$
00105$:
C$i2c.h$102$1$81 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:102: i2c_write_data(0xC6, 0x00, text, len);
mov _i2c_write_data_PARM_3,#_lcd_print_text_1_81
mov (_i2c_write_data_PARM_3 + 1),#(_lcd_print_text_1_81 >> 8)
mov (_i2c_write_data_PARM_3 + 2),#0x00
mov _i2c_write_data_PARM_2,#0x00
mov _i2c_write_data_PARM_4,r6
mov dpl,#0xc6
lcall _i2c_write_data
00109$:
pop _bp
C$i2c.h$103$1$81 ==.
XG$lcd_print$0$0 ==.
ret
;------------------------------------------------------------
;Allocation info for local variables in function 'lcd_clear'
;------------------------------------------------------------
;NumBytes Allocated with name '_lcd_clear_NumBytes_1_85'
;Cmd Allocated with name '_lcd_clear_Cmd_1_85'
;------------------------------------------------------------
G$lcd_clear$0$0 ==.
C$i2c.h$106$1$81 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:106: void lcd_clear()
; -----------------------------------------
; function lcd_clear
; -----------------------------------------
_lcd_clear:
C$i2c.h$108$1$81 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:108: unsigned char NumBytes=0, Cmd[2];
mov _lcd_clear_NumBytes_1_85,#0x00
C$i2c.h$110$1$85 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:110: while(NumBytes < 64) i2c_read_data(0xC6, 0x00, &NumBytes, 1);
00101$:
mov a,#0x100 - 0x40
add a,_lcd_clear_NumBytes_1_85
jc 00103$
mov _i2c_read_data_PARM_3,#_lcd_clear_NumBytes_1_85
mov (_i2c_read_data_PARM_3 + 1),#0x00
mov (_i2c_read_data_PARM_3 + 2),#0x40
mov _i2c_read_data_PARM_2,#0x00
mov _i2c_read_data_PARM_4,#0x01
mov dpl,#0xc6
lcall _i2c_read_data
sjmp 00101$
00103$:
C$i2c.h$112$1$85 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:112: Cmd[0] = 12;
mov _lcd_clear_Cmd_1_85,#0x0c
C$i2c.h$113$1$85 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:113: i2c_write_data(0xC6, 0x00, Cmd, 1);
mov _i2c_write_data_PARM_3,#_lcd_clear_Cmd_1_85
mov (_i2c_write_data_PARM_3 + 1),#0x00
mov (_i2c_write_data_PARM_3 + 2),#0x40
mov _i2c_write_data_PARM_2,#0x00
mov _i2c_write_data_PARM_4,#0x01
mov dpl,#0xc6
lcall _i2c_write_data
C$i2c.h$114$1$85 ==.
XG$lcd_clear$0$0 ==.
ret
;------------------------------------------------------------
;Allocation info for local variables in function 'read_keypad'
;------------------------------------------------------------
;i Allocated to registers r7
;Data Allocated with name '_read_keypad_Data_1_86'
;------------------------------------------------------------
G$read_keypad$0$0 ==.
C$i2c.h$117$1$85 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:117: char read_keypad()
; -----------------------------------------
; function read_keypad
; -----------------------------------------
_read_keypad:
C$i2c.h$121$1$86 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:121: i2c_read_data(0xC6, 0x01, Data, 2); //Read I2C data on address 192, register 1, 2 bytes of data.
mov _i2c_read_data_PARM_3,#_read_keypad_Data_1_86
mov (_i2c_read_data_PARM_3 + 1),#0x00
mov (_i2c_read_data_PARM_3 + 2),#0x40
mov _i2c_read_data_PARM_2,#0x01
mov _i2c_read_data_PARM_4,#0x02
mov dpl,#0xc6
lcall _i2c_read_data
C$i2c.h$122$1$86 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:122: if(Data[0] == 0xFF) return 0; //No response on bus, no display
mov a,#0xff
cjne a,_read_keypad_Data_1_86,00102$
mov dpl,#0x00
sjmp 00116$
00102$:
C$i2c.h$124$1$86 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:124: for(i=0; i<8; i++) //loop 8 times
mov r7,#0x00
mov ar6,r7
00114$:
C$i2c.h$126$2$87 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:126: if(Data[0] & (0x01 << i)) //find the ASCII value of the keypad read, if it is the current loop value
mov b,r6
inc b
mov r4,#0x01
mov r5,#0x00
sjmp 00145$
00144$:
mov a,r4
add a,r4
mov r4,a
mov a,r5
rlc a
mov r5,a
00145$:
djnz b,00144$
mov r2,_read_keypad_Data_1_86
mov r3,#0x00
mov a,r2
anl ar4,a
mov a,r3
anl ar5,a
mov a,r4
orl a,r5
jz 00115$
C$i2c.h$127$2$87 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:127: return i+49;
mov a,#0x31
add a,r7
mov dpl,a
sjmp 00116$
00115$:
C$i2c.h$124$1$86 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:124: for(i=0; i<8; i++) //loop 8 times
inc r6
mov ar7,r6
cjne r6,#0x08,00147$
00147$:
jc 00114$
C$i2c.h$130$1$86 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:130: if(Data[1] & 0x01) return '9'; //if the value is equal to 9 return 9.
mov a,(_read_keypad_Data_1_86 + 0x0001)
jnb acc.0,00107$
mov dpl,#0x39
sjmp 00116$
00107$:
C$i2c.h$132$1$86 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:132: if(Data[1] & 0x02) return '*'; //if the value is equal to the star.
mov a,(_read_keypad_Data_1_86 + 0x0001)
jnb acc.1,00109$
mov dpl,#0x2a
sjmp 00116$
00109$:
C$i2c.h$134$1$86 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:134: if(Data[1] & 0x04) return '0'; //if the value is equal to the 0 key
mov a,(_read_keypad_Data_1_86 + 0x0001)
jnb acc.2,00111$
mov dpl,#0x30
sjmp 00116$
00111$:
C$i2c.h$136$1$86 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:136: if(Data[1] & 0x08) return '#'; //if the value is equal to the pound key
mov a,(_read_keypad_Data_1_86 + 0x0001)
jnb acc.3,00113$
mov dpl,#0x23
sjmp 00116$
00113$:
C$i2c.h$138$1$86 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:138: return 0xFF; //else return a numerical -1 (0xFF)
mov dpl,#0xff
00116$:
C$i2c.h$139$1$86 ==.
XG$read_keypad$0$0 ==.
ret
;------------------------------------------------------------
;Allocation info for local variables in function 'kpd_input'
;------------------------------------------------------------
;mode Allocated to registers r7
;sum Allocated to registers r5 r6
;key Allocated to registers r3
;i Allocated to registers
;------------------------------------------------------------
G$kpd_input$0$0 ==.
C$i2c.h$151$1$86 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:151: unsigned int kpd_input(char mode)
; -----------------------------------------
; function kpd_input
; -----------------------------------------
_kpd_input:
mov r7,dpl
C$i2c.h$156$1$89 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:156: sum = 0;
C$i2c.h$159$1$89 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:159: if(mode==0)lcd_print("\nType digits; end w/#");
clr a
mov r5,a
mov r6,a
mov a,r7
jnz 00102$
push ar6
push ar5
mov a,#___str_0
push acc
mov a,#(___str_0 >> 8)
push acc
mov a,#0x80
push acc
lcall _lcd_print
dec sp
dec sp
dec sp
pop ar5
pop ar6
00102$:
C$i2c.h$161$1$89 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:161: lcd_print(" %c%c%c%c%c",0x08,0x08,0x08,0x08,0x08);
push ar6
push ar5
mov a,#0x08
push acc
clr a
push acc
mov a,#0x08
push acc
clr a
push acc
mov a,#0x08
push acc
clr a
push acc
mov a,#0x08
push acc
clr a
push acc
mov a,#0x08
push acc
clr a
push acc
mov a,#___str_1
push acc
mov a,#(___str_1 >> 8)
push acc
mov a,#0x80
push acc
lcall _lcd_print
mov a,sp
add a,#0xf3
mov sp,a
C$i2c.h$163$1$89 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:163: delay_time(500000); //Add 20ms delay before reading i2c in loop
mov dptr,#0xa120
mov b,#0x07
clr a
lcall _delay_time
pop ar5
pop ar6
C$i2c.h$167$1$89 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:167: for(i=0; i<5; i++)
mov r7,#0x00
C$i2c.h$169$3$92 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:169: while(((key=read_keypad()) == 0xFF) || (key == '*'))delay_time(10000);
00104$:
push ar7
push ar6
push ar5
lcall _read_keypad
mov r4,dpl
pop ar5
pop ar6
pop ar7
mov ar3,r4
cjne r4,#0xff,00146$
sjmp 00105$
00146$:
cjne r3,#0x2a,00106$
00105$:
mov dptr,#0x2710
clr a
mov b,a
push ar7
push ar6
push ar5
lcall _delay_time
pop ar5
pop ar6
pop ar7
sjmp 00104$
00106$:
C$i2c.h$170$2$90 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:170: if(key == '#')
cjne r3,#0x23,00114$
C$i2c.h$172$3$91 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:172: while(read_keypad() == '#')delay_time(10000);
00107$:
push ar6
push ar5
lcall _read_keypad
mov r4,dpl
pop ar5
pop ar6
cjne r4,#0x23,00109$
mov dptr,#0x2710
clr a
mov b,a
push ar6
push ar5
lcall _delay_time
pop ar5
pop ar6
sjmp 00107$
00109$:
C$i2c.h$173$3$91 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:173: return sum;
mov dpl,r5
mov dph,r6
ljmp 00119$
00114$:
C$i2c.h$177$3$92 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:177: lcd_print("%c", key);
mov ar2,r3
mov r4,#0x00
push ar7
push ar6
push ar5
push ar4
push ar3
push ar2
push ar2
push ar4
mov a,#___str_2
push acc
mov a,#(___str_2 >> 8)
push acc
mov a,#0x80
push acc
lcall _lcd_print
mov a,sp
add a,#0xfb
mov sp,a
pop ar2
pop ar3
pop ar4
pop ar5
pop ar6
C$i2c.h$178$1$89 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:178: sum = sum*10 + key - '0';
mov __mulint_PARM_2,r5
mov (__mulint_PARM_2 + 1),r6
mov dptr,#0x000a
push ar4
push ar3
push ar2
lcall __mulint
mov r0,dpl
mov r1,dph
pop ar2
pop ar3
pop ar4
pop ar7
mov a,r2
add a,r0
mov r0,a
mov a,r4
addc a,r1
mov r1,a
mov a,r0
add a,#0xd0
mov r5,a
mov a,r1
addc a,#0xff
mov r6,a
C$i2c.h$179$3$92 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:179: while(read_keypad() == key)delay_time(10000); //wait for key to be released
00110$:
push ar7
push ar6
push ar5
push ar3
lcall _read_keypad
mov r4,dpl
pop ar3
pop ar5
pop ar6
pop ar7
mov a,r4
cjne a,ar3,00118$
mov dptr,#0x2710
clr a
mov b,a
push ar7
push ar6
push ar5
push ar3
lcall _delay_time
pop ar3
pop ar5
pop ar6
pop ar7
sjmp 00110$
00118$:
C$i2c.h$167$1$89 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:167: for(i=0; i<5; i++)
inc r7
cjne r7,#0x05,00155$
00155$:
jnc 00156$
ljmp 00104$
00156$:
C$i2c.h$182$1$89 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:182: return sum;
mov dpl,r5
mov dph,r6
00119$:
C$i2c.h$183$1$89 ==.
XG$kpd_input$0$0 ==.
ret
;------------------------------------------------------------
;Allocation info for local variables in function 'delay_time'
;------------------------------------------------------------
;time_end Allocated to registers r4 r5 r6 r7
;index Allocated to registers
;------------------------------------------------------------
G$delay_time$0$0 ==.
C$i2c.h$192$1$89 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:192: void delay_time (unsigned long time_end)
; -----------------------------------------
; function delay_time
; -----------------------------------------
_delay_time:
mov r4,dpl
mov r5,dph
mov r6,b
mov r7,a
C$i2c.h$196$1$94 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:196: for (index = 0; index < time_end; index++); //for loop delay
mov r0,#0x00
mov r1,#0x00
mov r2,#0x00
mov r3,#0x00
00103$:
clr c
mov a,r0
subb a,r4
mov a,r1
subb a,r5
mov a,r2
subb a,r6
mov a,r3
subb a,r7
jnc 00105$
inc r0
cjne r0,#0x00,00115$
inc r1
cjne r1,#0x00,00115$
inc r2
cjne r2,#0x00,00103$
inc r3
00115$:
sjmp 00103$
00105$:
C$i2c.h$197$1$94 ==.
XG$delay_time$0$0 ==.
ret
;------------------------------------------------------------
;Allocation info for local variables in function 'i2c_start'
;------------------------------------------------------------
G$i2c_start$0$0 ==.
C$i2c.h$200$1$94 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:200: void i2c_start(void)
; -----------------------------------------
; function i2c_start
; -----------------------------------------
_i2c_start:
C$i2c.h$202$1$96 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:202: while(BUSY); //Wait until SMBus0 is free
00101$:
jb _BUSY,00101$
C$i2c.h$203$1$96 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:203: STA = 1; //Set Start Bit
setb _STA
C$i2c.h$204$1$96 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:204: while(!SI); //Wait until start sent
00104$:
jnb _SI,00104$
C$i2c.h$205$1$96 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:205: STA = 0; //Clear start bit
clr _STA
C$i2c.h$206$1$96 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:206: SI = 0; //Clear SI
clr _SI
C$i2c.h$207$1$96 ==.
XG$i2c_start$0$0 ==.
ret
;------------------------------------------------------------
;Allocation info for local variables in function 'i2c_write'
;------------------------------------------------------------
;output_data Allocated to registers
;------------------------------------------------------------
G$i2c_write$0$0 ==.
C$i2c.h$210$1$96 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:210: void i2c_write(unsigned char output_data)
; -----------------------------------------
; function i2c_write
; -----------------------------------------
_i2c_write:
mov _SMB0DAT,dpl
C$i2c.h$213$1$98 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:213: while(!SI); //Wait until send is complete
00101$:
C$i2c.h$214$1$98 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:214: SI = 0; //Clear SI
jbc _SI,00112$
sjmp 00101$
00112$:
C$i2c.h$215$1$98 ==.
XG$i2c_write$0$0 ==.
ret
;------------------------------------------------------------
;Allocation info for local variables in function 'i2c_write_and_stop'
;------------------------------------------------------------
;output_data Allocated to registers
;------------------------------------------------------------
G$i2c_write_and_stop$0$0 ==.
C$i2c.h$218$1$98 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:218: void i2c_write_and_stop(unsigned char output_data)
; -----------------------------------------
; function i2c_write_and_stop
; -----------------------------------------
_i2c_write_and_stop:
mov _SMB0DAT,dpl
C$i2c.h$221$1$100 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:221: STO = 1; //Set stop bit
setb _STO
C$i2c.h$222$1$100 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:222: while(!SI); //Wait until send is complete
00101$:
C$i2c.h$223$1$100 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:223: SI = 0; //Clear SI
jbc _SI,00112$
sjmp 00101$
00112$:
C$i2c.h$224$1$100 ==.
XG$i2c_write_and_stop$0$0 ==.
ret
;------------------------------------------------------------
;Allocation info for local variables in function 'i2c_read'
;------------------------------------------------------------
;input_data Allocated to registers
;------------------------------------------------------------
G$i2c_read$0$0 ==.
C$i2c.h$227$1$100 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:227: unsigned char i2c_read(void)
; -----------------------------------------
; function i2c_read
; -----------------------------------------
_i2c_read:
C$i2c.h$231$1$102 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:231: while(!SI); //Wait until we have data to read
00101$:
jnb _SI,00101$
C$i2c.h$232$1$102 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:232: input_data = SMB0DAT; //Read the data
mov dpl,_SMB0DAT
C$i2c.h$233$1$102 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:233: SI = 0; //Clear SI
clr _SI
C$i2c.h$234$1$102 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:234: return input_data; //Return the read data
C$i2c.h$235$1$102 ==.
XG$i2c_read$0$0 ==.
ret
;------------------------------------------------------------
;Allocation info for local variables in function 'i2c_read_and_stop'
;------------------------------------------------------------
;input_data Allocated to registers r7
;------------------------------------------------------------
G$i2c_read_and_stop$0$0 ==.
C$i2c.h$238$1$102 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:238: unsigned char i2c_read_and_stop(void)
; -----------------------------------------
; function i2c_read_and_stop
; -----------------------------------------
_i2c_read_and_stop:
C$i2c.h$242$1$104 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:242: while(!SI); //Wait until we have data to read
00101$:
jnb _SI,00101$
C$i2c.h$243$1$104 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:243: input_data = SMB0DAT; //Read the data
mov r7,_SMB0DAT
C$i2c.h$244$1$104 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:244: SI = 0; //Clear SI
clr _SI
C$i2c.h$245$1$104 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:245: STO = 1; //Set stop bit
setb _STO
C$i2c.h$246$1$104 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:246: while(!SI); //Wait for stop
00104$:
C$i2c.h$247$1$104 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:247: SI = 0;
jbc _SI,00122$
sjmp 00104$
00122$:
C$i2c.h$248$1$104 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:248: return input_data; //Return the read data
mov dpl,r7
C$i2c.h$249$1$104 ==.
XG$i2c_read_and_stop$0$0 ==.
ret
;------------------------------------------------------------
;Allocation info for local variables in function 'i2c_write_data'
;------------------------------------------------------------
;start_reg Allocated with name '_i2c_write_data_PARM_2'
;buffer Allocated with name '_i2c_write_data_PARM_3'
;num_bytes Allocated with name '_i2c_write_data_PARM_4'
;addr Allocated to registers r7
;i Allocated to registers
;------------------------------------------------------------
G$i2c_write_data$0$0 ==.
C$i2c.h$252$1$104 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:252: void i2c_write_data(unsigned char addr, unsigned char start_reg, unsigned char *buffer, unsigned char num_bytes)
; -----------------------------------------
; function i2c_write_data
; -----------------------------------------
_i2c_write_data:
mov r7,dpl
C$i2c.h$256$1$106 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:256: EA = 0; //Don't allow interrupts during I2C work
clr _EA
C$i2c.h$257$1$106 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:257: i2c_start(); //Initiate I2C transfer
push ar7
lcall _i2c_start
pop ar7
C$i2c.h$258$1$106 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:258: i2c_write(addr & ~0x01); //Write the desired address to the bus
mov a,#0xfe
anl a,r7
mov dpl,a
lcall _i2c_write
C$i2c.h$259$1$106 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:259: i2c_write(start_reg); //Write the start register to the bus
mov dpl,_i2c_write_data_PARM_2
lcall _i2c_write
C$i2c.h$260$1$106 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:260: for(i=0; i<num_bytes-1; i++) //Write the data to the register(s)
mov r7,#0x00
00103$:
mov r5,_i2c_write_data_PARM_4
mov r6,#0x00
dec r5
cjne r5,#0xff,00114$
dec r6
00114$:
mov ar3,r7
mov r4,#0x00
clr c
mov a,r3
subb a,r5
mov a,r4
xrl a,#0x80
mov b,r6
xrl b,#0x80
subb a,b
jnc 00101$
C$i2c.h$261$1$106 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:261: i2c_write(buffer[i]);
mov a,r7
add a,_i2c_write_data_PARM_3
mov r4,a
clr a
addc a,(_i2c_write_data_PARM_3 + 1)
mov r5,a
mov r6,(_i2c_write_data_PARM_3 + 2)
mov dpl,r4
mov dph,r5
mov b,r6
lcall __gptrget
mov dpl,a
push ar7
lcall _i2c_write
pop ar7
C$i2c.h$260$1$106 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:260: for(i=0; i<num_bytes-1; i++) //Write the data to the register(s)
inc r7
sjmp 00103$
00101$:
C$i2c.h$262$1$106 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:262: i2c_write_and_stop(buffer[num_bytes-1]); //Stop transfer
mov r6,_i2c_write_data_PARM_4
mov r7,#0x00
dec r6
cjne r6,#0xff,00116$
dec r7
00116$:
mov a,r6
add a,_i2c_write_data_PARM_3
mov r6,a
mov a,r7
addc a,(_i2c_write_data_PARM_3 + 1)
mov r7,a
mov r5,(_i2c_write_data_PARM_3 + 2)
mov dpl,r6
mov dph,r7
mov b,r5
lcall __gptrget
mov dpl,a
lcall _i2c_write_and_stop
C$i2c.h$263$1$106 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:263: EA = 1; //Re-Enable interrupts
setb _EA
C$i2c.h$264$1$106 ==.
XG$i2c_write_data$0$0 ==.
ret
;------------------------------------------------------------
;Allocation info for local variables in function 'i2c_read_data'
;------------------------------------------------------------
;start_reg Allocated with name '_i2c_read_data_PARM_2'
;buffer Allocated with name '_i2c_read_data_PARM_3'
;num_bytes Allocated with name '_i2c_read_data_PARM_4'
;addr Allocated to registers r7
;j Allocated to registers
;------------------------------------------------------------
G$i2c_read_data$0$0 ==.
C$i2c.h$267$1$106 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:267: void i2c_read_data(unsigned char addr, unsigned char start_reg, unsigned char *buffer, unsigned char num_bytes)
; -----------------------------------------
; function i2c_read_data
; -----------------------------------------
_i2c_read_data:
mov r7,dpl
C$i2c.h$271$1$108 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:271: EA = 0; //Don't allow interrupts during I2C work
clr _EA
C$i2c.h$272$1$108 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:272: i2c_start(); //Start I2C transfer
push ar7
lcall _i2c_start
pop ar7
C$i2c.h$273$1$108 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:273: i2c_write(addr & ~0x01); //Write address of device that will be written to, send 0
mov a,#0xfe
anl a,r7
mov dpl,a
push ar7
lcall _i2c_write
C$i2c.h$274$1$108 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:274: i2c_write_and_stop(start_reg); //Write & stop the 1st register to be read
mov dpl,_i2c_read_data_PARM_2
lcall _i2c_write_and_stop
C$i2c.h$275$1$108 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:275: i2c_start(); //Start I2C transfer
lcall _i2c_start
pop ar7
C$i2c.h$276$1$108 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:276: i2c_write(addr | 0x01); //Write address again, this time indicating a read operation
mov a,#0x01
orl a,r7
mov dpl,a
lcall _i2c_write
C$i2c.h$277$1$108 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:277: for(j = 0; j < num_bytes - 1; j++)
mov r7,#0x00
00103$:
mov r5,_i2c_read_data_PARM_4
mov r6,#0x00
dec r5
cjne r5,#0xff,00114$
dec r6
00114$:
mov ar3,r7
mov r4,#0x00
clr c
mov a,r3
subb a,r5
mov a,r4
xrl a,#0x80
mov b,r6
xrl b,#0x80
subb a,b
jnc 00101$
C$i2c.h$279$2$109 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:279: AA = 1; //Set acknowledge bit
setb _AA
C$i2c.h$280$2$109 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:280: buffer[j] = i2c_read(); //Read data, save it in buffer
mov a,r7
add a,_i2c_read_data_PARM_3
mov r4,a
clr a
addc a,(_i2c_read_data_PARM_3 + 1)
mov r5,a
mov r6,(_i2c_read_data_PARM_3 + 2)
push ar7
push ar6
push ar5
push ar4
lcall _i2c_read
mov r3,dpl
pop ar4
pop ar5
pop ar6
pop ar7
mov dpl,r4
mov dph,r5
mov b,r6
mov a,r3
lcall __gptrput
C$i2c.h$277$1$108 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:277: for(j = 0; j < num_bytes - 1; j++)
inc r7
sjmp 00103$
00101$:
C$i2c.h$282$1$108 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:282: AA = 0;
clr _AA
C$i2c.h$283$1$108 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:283: buffer[num_bytes - 1] = i2c_read_and_stop(); //Read the last byte and stop, save it in the buffer
mov r6,_i2c_read_data_PARM_4
mov r7,#0x00
dec r6
cjne r6,#0xff,00116$
dec r7
00116$:
mov a,r6
add a,_i2c_read_data_PARM_3
mov r6,a
mov a,r7
addc a,(_i2c_read_data_PARM_3 + 1)
mov r7,a
mov r5,(_i2c_read_data_PARM_3 + 2)
push ar7
push ar6
push ar5
lcall _i2c_read_and_stop
mov r4,dpl
pop ar5
pop ar6
pop ar7
mov dpl,r6
mov dph,r7
mov b,r5
mov a,r4
lcall __gptrput
C$i2c.h$284$1$108 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:284: EA = 1; //Re-Enable interrupts
setb _EA
C$i2c.h$285$1$108 ==.
XG$i2c_read_data$0$0 ==.
ret
;------------------------------------------------------------
;Allocation info for local variables in function 'Accel_Init'
;------------------------------------------------------------
G$Accel_Init$0$0 ==.
C$i2c.h$294$1$108 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:294: void Accel_Init(void)
; -----------------------------------------
; function Accel_Init
; -----------------------------------------
_Accel_Init:
C$i2c.h$298$1$111 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:298: Data2[0]=0x23; //normal power mode, 50Hz ODR, y & x axes enabled
mov _Data2,#0x23
C$i2c.h$300$1$111 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:300: Data2[1]=0x00; //default - no filtering
mov (_Data2 + 0x0001),#0x00
C$i2c.h$301$1$111 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:301: Data2[1]=0x10; //filtered data selected, HPF = 1.0->0.125Hz
mov (_Data2 + 0x0001),#0x10
C$i2c.h$302$1$111 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:302: Data2[2]=0x00; //default - no interrupts enabled
mov (_Data2 + 0x0002),#0x00
C$i2c.h$304$1$111 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:304: i2c_write_data(addr_accel, 0x20, Data2, 1);
mov _i2c_write_data_PARM_3,#_Data2
mov (_i2c_write_data_PARM_3 + 1),#0x00
mov (_i2c_write_data_PARM_3 + 2),#0x40
mov _i2c_write_data_PARM_2,#0x20
mov _i2c_write_data_PARM_4,#0x01
mov dpl,#0x30
lcall _i2c_write_data
C$i2c.h$310$1$111 ==.
XG$Accel_Init$0$0 ==.
ret
;------------------------------------------------------------
;Allocation info for local variables in function 'Accel_Init_C'
;------------------------------------------------------------
G$Accel_Init_C$0$0 ==.
C$i2c.h$313$1$111 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:313: void Accel_Init_C(void)
; -----------------------------------------
; function Accel_Init_C
; -----------------------------------------
_Accel_Init_C:
C$i2c.h$318$1$113 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:318: Data2[0]=0x04; //set register address auto increment bit
mov _Data2,#0x04
C$i2c.h$319$1$113 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:319: i2c_write_data(addr_accelC, 0x23, Data2, 1);
mov _i2c_write_data_PARM_3,#_Data2
mov (_i2c_write_data_PARM_3 + 1),#0x00
mov (_i2c_write_data_PARM_3 + 2),#0x40
mov _i2c_write_data_PARM_2,#0x23
mov _i2c_write_data_PARM_4,#0x01
mov dpl,#0x3a
lcall _i2c_write_data
C$i2c.h$321$1$113 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:321: Data2[0]=0x6B; //R20 normal power mode, 800Hz ODR, y & x axes enabled
mov _Data2,#0x6b
C$i2c.h$323$1$113 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:323: Data2[1]=0x00; //R21 Default - no HP filtering
mov (_Data2 + 0x0001),#0x00
C$i2c.h$325$1$113 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:325: Data2[2]=0x00; //R22 Default - no interrupts enabled
mov (_Data2 + 0x0002),#0x00
C$i2c.h$326$1$113 ==.
; C:/Program Files/SDCC/bin/../include/mcs51/i2c.h:326: i2c_write_data(addr_accelC, 0x20, Data2, 1);
mov _i2c_write_data_PARM_3,#_Data2
mov (_i2c_write_data_PARM_3 + 1),#0x00
mov (_i2c_write_data_PARM_3 + 2),#0x40
mov _i2c_write_data_PARM_2,#0x20
mov _i2c_write_data_PARM_4,#0x01
mov dpl,#0x3a
lcall _i2c_write_data
C$i2c.h$328$1$113 ==.
XG$Accel_Init_C$0$0 ==.
ret
;------------------------------------------------------------
;Allocation info for local variables in function 'main'
;------------------------------------------------------------
G$main$0$0 ==.
C$lab3compass.c$29$1$113 ==.
; C:\SiLabs\LITEC\Lab3\lab3compass.c:29: void main(void)
; -----------------------------------------
; function main
; -----------------------------------------
_main:
C$lab3compass.c$33$1$121 ==.
; C:\SiLabs\LITEC\Lab3\lab3compass.c:33: Sys_Init();
lcall _Sys_Init
C$lab3compass.c$34$1$121 ==.
; C:\SiLabs\LITEC\Lab3\lab3compass.c:34: putchar(' '); //the quotes in this line may not format correctly
mov dpl,#0x20
lcall _putchar
C$lab3compass.c$37$1$121 ==.
; C:\SiLabs\LITEC\Lab3\lab3compass.c:37: XBR0_Init();
lcall _XBR0_Init
C$lab3compass.c$39$1$121 ==.
; C:\SiLabs\LITEC\Lab3\lab3compass.c:39: PCA_Init();
lcall _PCA_Init
C$lab3compass.c$40$1$121 ==.
; C:\SiLabs\LITEC\Lab3\lab3compass.c:40: SMB_Init();
lcall _SMB_Init
C$lab3compass.c$41$1$121 ==.
; C:\SiLabs\LITEC\Lab3\lab3compass.c:41: Interrupt_Init();
lcall _Interrupt_Init
C$lab3compass.c$43$1$121 ==.
; C:\SiLabs\LITEC\Lab3\lab3compass.c:43: printf("\n\rCompass Reading\n\r");
mov a,#___str_3
push acc
mov a,#(___str_3 >> 8)
push acc
mov a,#0x80
push acc
lcall _printf
dec sp
dec sp
dec sp
C$lab3compass.c$44$1$121 ==.
; C:\SiLabs\LITEC\Lab3\lab3compass.c:44: count=0;
clr a
mov _count,a
mov (_count + 1),a
C$lab3compass.c$45$1$121 ==.
; C:\SiLabs\LITEC\Lab3\lab3compass.c:45: while(1) {
00106$:
C$lab3compass.c$46$2$122 ==.
; C:\SiLabs\LITEC\Lab3\lab3compass.c:46: if(count>=2) {//every 40ms
clr c
mov a,_count
subb a,#0x02
mov a,(_count + 1)
subb a,#0x00
jc 00106$
C$lab3compass.c$47$3$123 ==.
; C:\SiLabs\LITEC\Lab3\lab3compass.c:47: print_count++;
inc _print_count
clr a
cjne a,_print_count,00120$
inc (_print_count + 1)
00120$:
C$lab3compass.c$48$3$123 ==.
; C:\SiLabs\LITEC\Lab3\lab3compass.c:48: Read_Compass();//get compass reading
lcall _Read_Compass
C$lab3compass.c$49$3$123 ==.
; C:\SiLabs\LITEC\Lab3\lab3compass.c:49: if(print_count>=25) {//only print results every 1 second
clr c
mov a,_print_count
subb a,#0x19
mov a,(_print_count + 1)
subb a,#0x00
jc 00102$
C$lab3compass.c$50$4$124 ==.
; C:\SiLabs\LITEC\Lab3\lab3compass.c:50: printf("Reading: %u\n\r", reading);
push _reading
push (_reading + 1)
mov a,#___str_4
push acc
mov a,#(___str_4 >> 8)
push acc
mov a,#0x80
push acc
lcall _printf
mov a,sp
add a,#0xfb
mov sp,a
C$lab3compass.c$51$4$124 ==.
; C:\SiLabs\LITEC\Lab3\lab3compass.c:51: print_count=0;
clr a
mov _print_count,a
mov (_print_count + 1),a
00102$:
C$lab3compass.c$53$3$123 ==.
; C:\SiLabs\LITEC\Lab3\lab3compass.c:53: count=0;
clr a
mov _count,a
mov (_count + 1),a
sjmp 00106$
C$lab3compass.c$57$1$121 ==.
XG$main$0$0 ==.
ret
;------------------------------------------------------------
;Allocation info for local variables in function 'Port_Init'
;------------------------------------------------------------
G$Port_Init$0$0 ==.
C$lab3compass.c$64$1$121 ==.
; C:\SiLabs\LITEC\Lab3\lab3compass.c:64: void Port_Init()//DONT NEED TO INIT PORTS IN THIS PROGRAM
; -----------------------------------------
; function Port_Init
; -----------------------------------------
_Port_Init:
C$lab3compass.c$68$1$121 ==.
; C:\SiLabs\LITEC\Lab3\lab3compass.c:68: }
C$lab3compass.c$68$1$121 ==.
XG$Port_Init$0$0 ==.
ret
;------------------------------------------------------------
;Allocation info for local variables in function 'XBR0_Init'
;------------------------------------------------------------
G$XBR0_Init$0$0 ==.
C$lab3compass.c$75$1$121 ==.
; C:\SiLabs\LITEC\Lab3\lab3compass.c:75: void XBR0_Init()
; -----------------------------------------
; function XBR0_Init
; -----------------------------------------
_XBR0_Init:
C$lab3compass.c$77$1$126 ==.
; C:\SiLabs\LITEC\Lab3\lab3compass.c:77: XBR0 = 0x27 ; //configure crossbar with UART, SPI, SMBus, and CEX channels
mov _XBR0,#0x27
C$lab3compass.c$78$1$126 ==.
XG$XBR0_Init$0$0 ==.
ret
;------------------------------------------------------------
;Allocation info for local variables in function 'SMB_Init'
;------------------------------------------------------------
G$SMB_Init$0$0 ==.
C$lab3compass.c$80$1$126 ==.
; C:\SiLabs\LITEC\Lab3\lab3compass.c:80: void SMB_Init(void) {
; -----------------------------------------
; function SMB_Init
; -----------------------------------------
_SMB_Init:
C$lab3compass.c$81$1$128 ==.
; C:\SiLabs\LITEC\Lab3\lab3compass.c:81: SMB0CR = 0x93; //run at 100kHZ
mov _SMB0CR,#0x93
C$lab3compass.c$82$1$128 ==.
; C:\SiLabs\LITEC\Lab3\lab3compass.c:82: ENSMB = 1; //enable smbus
setb _ENSMB
C$lab3compass.c$83$1$128 ==.
XG$SMB_Init$0$0 ==.
ret
;------------------------------------------------------------
;Allocation info for local variables in function 'PCA_Init'
;------------------------------------------------------------
G$PCA_Init$0$0 ==.
C$lab3compass.c$90$1$128 ==.
; C:\SiLabs\LITEC\Lab3\lab3compass.c:90: void PCA_Init(void)
; -----------------------------------------
; function PCA_Init
; -----------------------------------------
_PCA_Init:
C$lab3compass.c$92$1$130 ==.
; C:\SiLabs\LITEC\Lab3\lab3compass.c:92: PCA0MD = 0x81; //SYSCLK/12, enable CF interrupts, suspend when idle
mov _PCA0MD,#0x81
C$lab3compass.c$93$1$130 ==.
; C:\SiLabs\LITEC\Lab3\lab3compass.c:93: PCA0CPM0 = 0xC2; //16 bit, enable compare, enable PWM
mov _PCA0CPM0,#0xc2
C$lab3compass.c$94$1$130 ==.
; C:\SiLabs\LITEC\Lab3\lab3compass.c:94: PCA0CN |= 0x40; // enable PCA
orl _PCA0CN,#0x40
C$lab3compass.c$95$1$130 ==.
XG$PCA_Init$0$0 ==.
ret
;------------------------------------------------------------
;Allocation info for local variables in function 'Interrupt_Init'
;------------------------------------------------------------
G$Interrupt_Init$0$0 ==.
C$lab3compass.c$97$1$130 ==.
; C:\SiLabs\LITEC\Lab3\lab3compass.c:97: void Interrupt_Init(void)
; -----------------------------------------
; function Interrupt_Init
; -----------------------------------------
_Interrupt_Init:
C$lab3compass.c$99$1$132 ==.
; C:\SiLabs\LITEC\Lab3\lab3compass.c:99: EIE1 |= 0x08;//enable PCA interrupts
orl _EIE1,#0x08
C$lab3compass.c$100$1$132 ==.
; C:\SiLabs\LITEC\Lab3\lab3compass.c:100: EA=1;//enable all interrupts
setb _EA
C$lab3compass.c$101$1$132 ==.
XG$Interrupt_Init$0$0 ==.
ret
;------------------------------------------------------------
;Allocation info for local variables in function 'PCA_ISR'
;------------------------------------------------------------
G$PCA_ISR$0$0 ==.
C$lab3compass.c$108$1$132 ==.
; C:\SiLabs\LITEC\Lab3\lab3compass.c:108: void PCA_ISR ( void ) __interrupt 9
; -----------------------------------------
; function PCA_ISR
; -----------------------------------------
_PCA_ISR:
push acc
push psw
C$lab3compass.c$110$1$134 ==.
; C:\SiLabs\LITEC\Lab3\lab3compass.c:110: if(CF) {
jnb _CF,00102$
C$lab3compass.c$111$2$135 ==.
; C:\SiLabs\LITEC\Lab3\lab3compass.c:111: PCA0 = PCA_start;//Start count
mov ((_PCA0 >> 0) & 0xFF),_PCA_start
mov ((_PCA0 >> 8) & 0xFF),(_PCA_start + 1)
C$lab3compass.c$112$2$135 ==.
; C:\SiLabs\LITEC\Lab3\lab3compass.c:112: CF=0;//clear interrupt flag
clr _CF
C$lab3compass.c$113$2$135 ==.
; C:\SiLabs\LITEC\Lab3\lab3compass.c:113: count++;
inc _count
clr a
cjne a,_count,00104$
inc (_count + 1)
sjmp 00104$
00102$:
C$lab3compass.c$115$1$134 ==.
; C:\SiLabs\LITEC\Lab3\lab3compass.c:115: else PCA0CN &= 0xC0;//all other type 9 interrupts
anl _PCA0CN,#0xc0
00104$:
pop psw
pop acc
C$lab3compass.c$116$1$134 ==.
XG$PCA_ISR$0$0 ==.
reti
; eliminated unneeded mov psw,# (no regs used in bank)
; eliminated unneeded push/pop dpl
; eliminated unneeded push/pop dph
; eliminated unneeded push/pop b
;------------------------------------------------------------
;Allocation info for local variables in function 'Read_Compass'
;------------------------------------------------------------
;buffer Allocated with name '_Read_Compass_buffer_1_137'
;------------------------------------------------------------
G$Read_Compass$0$0 ==.
C$lab3compass.c$118$1$134 ==.
; C:\SiLabs\LITEC\Lab3\lab3compass.c:118: void Read_Compass(void) {
; -----------------------------------------
; function Read_Compass
; -----------------------------------------
_Read_Compass:
C$lab3compass.c$120$1$137 ==.
; C:\SiLabs\LITEC\Lab3\lab3compass.c:120: i2c_read_data(0xC0, 2, buffer, 2);//read two bytes starting at reg. 2
mov _i2c_read_data_PARM_3,#_Read_Compass_buffer_1_137
mov (_i2c_read_data_PARM_3 + 1),#0x00
mov (_i2c_read_data_PARM_3 + 2),#0x40
mov _i2c_read_data_PARM_2,#0x02
mov _i2c_read_data_PARM_4,#0x02
mov dpl,#0xc0
lcall _i2c_read_data
C$lab3compass.c$121$1$137 ==.
; C:\SiLabs\LITEC\Lab3\lab3compass.c:121: reading = (((unsigned int)buffer[0]<<8) | buffer[1]);//combine data
mov r7,_Read_Compass_buffer_1_137
mov r6,#0x00
mov r4,(_Read_Compass_buffer_1_137 + 0x0001)
mov r5,#0x00
mov a,r4
orl a,r6
mov _reading,a
mov a,r5
orl a,r7
mov (_reading + 1),a
C$lab3compass.c$122$1$137 ==.
XG$Read_Compass$0$0 ==.
ret
.area CSEG (CODE)
.area CONST (CODE)
Flab3compass$__str_0$0$0 == .
___str_0:
.db 0x0a
.ascii "Type digits; end w/#"
.db 0x00
Flab3compass$__str_1$0$0 == .
___str_1:
.ascii " %c%c%c%c%c"
.db 0x00
Flab3compass$__str_2$0$0 == .
___str_2:
.ascii "%c"
.db 0x00
Flab3compass$__str_3$0$0 == .
___str_3:
.db 0x0a
.db 0x0d
.ascii "Compass Reading"
.db 0x0a
.db 0x0d
.db 0x00
Flab3compass$__str_4$0$0 == .
___str_4:
.ascii "Reading: %u"
.db 0x0a
.db 0x0d
.db 0x00
.area XINIT (CODE)
.area CABS (ABS,CODE)
|
; Audio interfaces.
MapSetup_Sound_Off::
push hl
push de
push bc
push af
ldh a, [hROMBank]
push af
ld a, BANK(_MapSetup_Sound_Off)
ldh [hROMBank], a
ld [MBC3RomBank], a
call _MapSetup_Sound_Off
pop af
ldh [hROMBank], a
ld [MBC3RomBank], a
pop af
pop bc
pop de
pop hl
ret
UpdateSound::
push hl
push de
push bc
push af
ldh a, [hROMBank]
push af
ld a, BANK(_UpdateSound)
ldh [hROMBank], a
ld [MBC3RomBank], a
call _UpdateSound
pop af
ldh [hROMBank], a
ld [MBC3RomBank], a
pop af
pop bc
pop de
pop hl
ret
_LoadMusicByte::
; wCurMusicByte = [a:de]
ldh [hROMBank], a
ld [MBC3RomBank], a
ld a, [de]
ld [wCurMusicByte], a
ld a, BANK(LoadMusicByte)
ldh [hROMBank], a
ld [MBC3RomBank], a
ret
PlayMusic::
; Play music de.
push hl
push de
push bc
push af
ldh a, [hROMBank]
push af
ld a, BANK(_PlayMusic) ; aka BANK(_MapSetup_Sound_Off)
ldh [hROMBank], a
ld [MBC3RomBank], a
ld a, e
and a
jr z, .nomusic
call _PlayMusic
jr .end
.nomusic
call _MapSetup_Sound_Off
.end
pop af
ldh [hROMBank], a
ld [MBC3RomBank], a
pop af
pop bc
pop de
pop hl
ret
PlayMusic2::
; Stop playing music, then play music de.
push hl
push de
push bc
push af
ldh a, [hROMBank]
push af
ld a, BANK(_PlayMusic)
ldh [hROMBank], a
ld [MBC3RomBank], a
push de
ld de, MUSIC_NONE
call _PlayMusic
call DelayFrame
pop de
call _PlayMusic
pop af
ldh [hROMBank], a
ld [MBC3RomBank], a
pop af
pop bc
pop de
pop hl
ret
PlayCry::
; Play cry de.
push hl
push de
push bc
push af
ldh a, [hROMBank]
push af
; Cries are stuck in one bank.
ld a, BANK(PokemonCries)
ldh [hROMBank], a
ld [MBC3RomBank], a
ld hl, PokemonCries
rept 6 ; sizeof(mon_cry)
add hl, de
endr
ld e, [hl]
inc hl
ld d, [hl]
inc hl
ld a, [hli]
ld [wCryPitch], a
ld a, [hli]
ld [wCryPitch + 1], a
ld a, [hli]
ld [wCryLength], a
ld a, [hl]
ld [wCryLength + 1], a
ld a, BANK(_PlayCry)
ldh [hROMBank], a
ld [MBC3RomBank], a
call _PlayCry
pop af
ldh [hROMBank], a
ld [MBC3RomBank], a
pop af
pop bc
pop de
pop hl
ret
PlaySFX::
; Play sound effect de.
; Sound effects are ordered by priority (highest to lowest)
push hl
push de
push bc
push af
; Is something already playing?
call CheckSFX
jr nc, .play
; Does it have priority?
ld a, [wCurSFX]
cp e
jr c, .done
.play
ldh a, [hROMBank]
push af
ld a, BANK(_PlaySFX)
ldh [hROMBank], a
ld [MBC3RomBank], a
ld a, e
ld [wCurSFX], a
call _PlaySFX
pop af
ldh [hROMBank], a
ld [MBC3RomBank], a
.done
pop af
pop bc
pop de
pop hl
ret
WaitPlaySFX::
call WaitSFX
jp PlaySFX
WaitSFX::
; infinite loop until sfx is done playing
push hl
.wait
ld hl, wChannel5Flags1
bit 0, [hl]
jr nz, .wait
ld hl, wChannel6Flags1
bit 0, [hl]
jr nz, .wait
ld hl, wChannel7Flags1
bit 0, [hl]
jr nz, .wait
ld hl, wChannel8Flags1
bit 0, [hl]
jr nz, .wait
pop hl
ret
IsSFXPlaying::
; Return carry if no sound effect is playing.
; The inverse of CheckSFX.
push hl
ld hl, wChannel5Flags1
bit 0, [hl]
jr nz, .playing
ld hl, wChannel6Flags1
bit 0, [hl]
jr nz, .playing
ld hl, wChannel7Flags1
bit 0, [hl]
jr nz, .playing
ld hl, wChannel8Flags1
bit 0, [hl]
jr nz, .playing
pop hl
scf
ret
.playing
pop hl
and a
ret
MaxVolume::
ld a, MAX_VOLUME
ld [wVolume], a
ret
LowVolume::
ld a, $33 ; 40%
ld [wVolume], a
ret
VolumeOff::
xor a
ld [wVolume], a
ret
Unused_FadeOutMusic::
ld a, 4
ld [wMusicFade], a
ret
FadeInMusic::
ld a, 4 | (1 << MUSIC_FADE_IN_F)
ld [wMusicFade], a
ret
SkipMusic::
; Skip a frames of music.
.loop
and a
ret z
dec a
call UpdateSound
jr .loop
FadeToMapMusic::
push hl
push de
push bc
push af
call GetMapMusic_MaybeSpecial
ld a, [wMapMusic]
cp e
jr z, .done
ld a, 8
ld [wMusicFade], a
ld a, e
ld [wMusicFadeID], a
ld a, d
ld [wMusicFadeID + 1], a
ld a, e
ld [wMapMusic], a
.done
pop af
pop bc
pop de
pop hl
ret
PlayMapMusic::
push hl
push de
push bc
push af
call GetMapMusic_MaybeSpecial
ld a, [wMapMusic]
cp e
jr z, .done
push de
ld de, MUSIC_NONE
call PlayMusic
call DelayFrame
pop de
ld a, e
ld [wMapMusic], a
call PlayMusic
.done
pop af
pop bc
pop de
pop hl
ret
EnterMapMusic::
push hl
push de
push bc
push af
xor a
ld [wDontPlayMapMusicOnReload], a
ld de, MUSIC_BICYCLE
ld a, [wPlayerState]
cp PLAYER_BIKE
jr z, .play
call GetMapMusic_MaybeSpecial
.play
push de
ld de, MUSIC_NONE
call PlayMusic
call DelayFrame
pop de
ld a, e
ld [wMapMusic], a
call PlayMusic
pop af
pop bc
pop de
pop hl
ret
TryRestartMapMusic::
ld a, [wDontPlayMapMusicOnReload]
and a
jr z, RestartMapMusic
xor a
ld [wMapMusic], a
ld de, MUSIC_NONE
call PlayMusic
call DelayFrame
xor a
ld [wDontPlayMapMusicOnReload], a
ret
RestartMapMusic::
push hl
push de
push bc
push af
ld de, MUSIC_NONE
call PlayMusic
call DelayFrame
ld a, [wMapMusic]
ld e, a
ld d, 0
call PlayMusic
pop af
pop bc
pop de
pop hl
ret
SpecialMapMusic::
ld a, [wPlayerState]
cp PLAYER_SURF
jr z, .surf
cp PLAYER_SURF_PIKA
jr z, .surf
ld a, [wStatusFlags2]
bit STATUSFLAGS2_BUG_CONTEST_TIMER_F, a
jr nz, .contest
.no
and a
ret
.bike
ld de, MUSIC_BICYCLE
scf
ret
.surf
ld de, MUSIC_SURF
scf
ret
.contest
ld a, [wMapGroup]
cp GROUP_ROUTE_35_NATIONAL_PARK_GATE
jr nz, .no
ld a, [wMapNumber]
cp MAP_ROUTE_35_NATIONAL_PARK_GATE
jr z, .ranking
cp MAP_ROUTE_36_NATIONAL_PARK_GATE
jr nz, .no
.ranking
ld de, MUSIC_BUG_CATCHING_CONTEST_RANKING
scf
ret
GetMapMusic_MaybeSpecial::
call SpecialMapMusic
ret c
jp GetMapMusic
CheckSFX::
; Return carry if any SFX channels are active.
ld a, [wChannel5Flags1]
bit 0, a
jr nz, .playing
ld a, [wChannel6Flags1]
bit 0, a
jr nz, .playing
ld a, [wChannel7Flags1]
bit 0, a
jr nz, .playing
ld a, [wChannel8Flags1]
bit 0, a
jr nz, .playing
and a
ret
.playing
scf
ret
TerminateExpBarSound::
xor a
ld [wChannel5Flags1], a
ld [wSoundInput], a
ldh [rNR10], a
ldh [rNR11], a
ldh [rNR12], a
ldh [rNR13], a
ldh [rNR14], a
ret
ChannelsOff::
; Quickly turn off music channels
xor a
ld [wChannel1Flags1], a
ld [wChannel2Flags1], a
ld [wChannel3Flags1], a
ld [wChannel4Flags1], a
ld [wSoundInput], a
ret
SFXChannelsOff::
; Quickly turn off sound effect channels
xor a
ld [wChannel5Flags1], a
ld [wChannel6Flags1], a
ld [wChannel7Flags1], a
ld [wChannel8Flags1], a
ld [wSoundInput], a
ret
|
#include <iostream>
#include "rx.h"
void next_func(int i);
int main()
{
rx::of({1, 3, 5, 7})
.subscribe(
next_func,
nullptr, //error_func
[]() { std::cout << "Completed" << std::endl; });
return 0;
}
void next_func(int i)
{
std::cout << "Next:" << i << std::endl;
} |
// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// utilities.cpp: Conversion functions and other utility routines.
#include "utilities.h"
#include "Framebuffer.h"
#include "main.h"
#include "mathutil.h"
#include "Context.h"
#include "Shader.h"
#include "common/debug.h"
#include <limits>
#include <stdio.h>
#include <stdlib.h>
namespace es2
{
unsigned int UniformComponentCount(GLenum type)
{
switch(type)
{
case GL_BOOL:
case GL_FLOAT:
case GL_INT:
case GL_UNSIGNED_INT:
case GL_SAMPLER_2D:
case GL_SAMPLER_CUBE:
case GL_SAMPLER_2D_RECT_ARB:
case GL_SAMPLER_EXTERNAL_OES:
case GL_SAMPLER_3D_OES:
case GL_SAMPLER_2D_ARRAY:
case GL_SAMPLER_2D_SHADOW:
case GL_SAMPLER_CUBE_SHADOW:
case GL_SAMPLER_2D_ARRAY_SHADOW:
case GL_INT_SAMPLER_2D:
case GL_UNSIGNED_INT_SAMPLER_2D:
case GL_INT_SAMPLER_CUBE:
case GL_UNSIGNED_INT_SAMPLER_CUBE:
case GL_INT_SAMPLER_3D:
case GL_UNSIGNED_INT_SAMPLER_3D:
case GL_INT_SAMPLER_2D_ARRAY:
case GL_UNSIGNED_INT_SAMPLER_2D_ARRAY:
return 1;
case GL_BOOL_VEC2:
case GL_FLOAT_VEC2:
case GL_INT_VEC2:
case GL_UNSIGNED_INT_VEC2:
return 2;
case GL_INT_VEC3:
case GL_UNSIGNED_INT_VEC3:
case GL_FLOAT_VEC3:
case GL_BOOL_VEC3:
return 3;
case GL_BOOL_VEC4:
case GL_FLOAT_VEC4:
case GL_INT_VEC4:
case GL_UNSIGNED_INT_VEC4:
case GL_FLOAT_MAT2:
return 4;
case GL_FLOAT_MAT2x3:
case GL_FLOAT_MAT3x2:
return 6;
case GL_FLOAT_MAT2x4:
case GL_FLOAT_MAT4x2:
return 8;
case GL_FLOAT_MAT3:
return 9;
case GL_FLOAT_MAT3x4:
case GL_FLOAT_MAT4x3:
return 12;
case GL_FLOAT_MAT4:
return 16;
default:
UNREACHABLE(type);
}
return 0;
}
GLenum UniformComponentType(GLenum type)
{
switch(type)
{
case GL_BOOL:
case GL_BOOL_VEC2:
case GL_BOOL_VEC3:
case GL_BOOL_VEC4:
return GL_BOOL;
case GL_FLOAT:
case GL_FLOAT_VEC2:
case GL_FLOAT_VEC3:
case GL_FLOAT_VEC4:
case GL_FLOAT_MAT2:
case GL_FLOAT_MAT2x3:
case GL_FLOAT_MAT2x4:
case GL_FLOAT_MAT3:
case GL_FLOAT_MAT3x2:
case GL_FLOAT_MAT3x4:
case GL_FLOAT_MAT4:
case GL_FLOAT_MAT4x2:
case GL_FLOAT_MAT4x3:
return GL_FLOAT;
case GL_INT:
case GL_SAMPLER_2D:
case GL_SAMPLER_CUBE:
case GL_SAMPLER_2D_RECT_ARB:
case GL_SAMPLER_EXTERNAL_OES:
case GL_SAMPLER_3D_OES:
case GL_SAMPLER_2D_ARRAY:
case GL_SAMPLER_2D_SHADOW:
case GL_SAMPLER_CUBE_SHADOW:
case GL_SAMPLER_2D_ARRAY_SHADOW:
case GL_INT_SAMPLER_2D:
case GL_UNSIGNED_INT_SAMPLER_2D:
case GL_INT_SAMPLER_CUBE:
case GL_UNSIGNED_INT_SAMPLER_CUBE:
case GL_INT_SAMPLER_3D:
case GL_UNSIGNED_INT_SAMPLER_3D:
case GL_INT_SAMPLER_2D_ARRAY:
case GL_UNSIGNED_INT_SAMPLER_2D_ARRAY:
case GL_INT_VEC2:
case GL_INT_VEC3:
case GL_INT_VEC4:
return GL_INT;
case GL_UNSIGNED_INT:
case GL_UNSIGNED_INT_VEC2:
case GL_UNSIGNED_INT_VEC3:
case GL_UNSIGNED_INT_VEC4:
return GL_UNSIGNED_INT;
default:
UNREACHABLE(type);
}
return GL_NONE;
}
size_t UniformTypeSize(GLenum type)
{
switch(type)
{
case GL_BOOL: return sizeof(GLboolean);
case GL_FLOAT: return sizeof(GLfloat);
case GL_INT: return sizeof(GLint);
case GL_UNSIGNED_INT: return sizeof(GLuint);
}
return UniformTypeSize(UniformComponentType(type)) * UniformComponentCount(type);
}
bool IsSamplerUniform(GLenum type)
{
switch(type)
{
case GL_SAMPLER_2D:
case GL_SAMPLER_CUBE:
case GL_SAMPLER_2D_RECT_ARB:
case GL_SAMPLER_EXTERNAL_OES:
case GL_SAMPLER_3D_OES:
case GL_SAMPLER_2D_ARRAY:
case GL_SAMPLER_2D_SHADOW:
case GL_SAMPLER_CUBE_SHADOW:
case GL_SAMPLER_2D_ARRAY_SHADOW:
case GL_INT_SAMPLER_2D:
case GL_UNSIGNED_INT_SAMPLER_2D:
case GL_INT_SAMPLER_CUBE:
case GL_UNSIGNED_INT_SAMPLER_CUBE:
case GL_INT_SAMPLER_3D:
case GL_UNSIGNED_INT_SAMPLER_3D:
case GL_INT_SAMPLER_2D_ARRAY:
case GL_UNSIGNED_INT_SAMPLER_2D_ARRAY:
return true;
default:
return false;
}
}
int VariableRowCount(GLenum type)
{
switch(type)
{
case GL_NONE:
return 0;
case GL_BOOL:
case GL_FLOAT:
case GL_INT:
case GL_UNSIGNED_INT:
case GL_BOOL_VEC2:
case GL_FLOAT_VEC2:
case GL_INT_VEC2:
case GL_UNSIGNED_INT_VEC2:
case GL_INT_VEC3:
case GL_UNSIGNED_INT_VEC3:
case GL_FLOAT_VEC3:
case GL_BOOL_VEC3:
case GL_BOOL_VEC4:
case GL_FLOAT_VEC4:
case GL_INT_VEC4:
case GL_UNSIGNED_INT_VEC4:
case GL_SAMPLER_2D:
case GL_SAMPLER_CUBE:
case GL_SAMPLER_2D_RECT_ARB:
case GL_SAMPLER_EXTERNAL_OES:
case GL_SAMPLER_3D_OES:
case GL_SAMPLER_2D_ARRAY:
case GL_SAMPLER_2D_SHADOW:
case GL_SAMPLER_CUBE_SHADOW:
case GL_SAMPLER_2D_ARRAY_SHADOW:
case GL_INT_SAMPLER_2D:
case GL_UNSIGNED_INT_SAMPLER_2D:
case GL_INT_SAMPLER_CUBE:
case GL_UNSIGNED_INT_SAMPLER_CUBE:
case GL_INT_SAMPLER_3D:
case GL_UNSIGNED_INT_SAMPLER_3D:
case GL_INT_SAMPLER_2D_ARRAY:
case GL_UNSIGNED_INT_SAMPLER_2D_ARRAY:
return 1;
case GL_FLOAT_MAT2:
case GL_FLOAT_MAT3x2:
case GL_FLOAT_MAT4x2:
return 2;
case GL_FLOAT_MAT3:
case GL_FLOAT_MAT2x3:
case GL_FLOAT_MAT4x3:
return 3;
case GL_FLOAT_MAT4:
case GL_FLOAT_MAT2x4:
case GL_FLOAT_MAT3x4:
return 4;
default:
UNREACHABLE(type);
}
return 0;
}
int VariableColumnCount(GLenum type)
{
switch(type)
{
case GL_NONE:
return 0;
case GL_BOOL:
case GL_FLOAT:
case GL_INT:
case GL_UNSIGNED_INT:
return 1;
case GL_BOOL_VEC2:
case GL_FLOAT_VEC2:
case GL_INT_VEC2:
case GL_UNSIGNED_INT_VEC2:
case GL_FLOAT_MAT2:
case GL_FLOAT_MAT2x3:
case GL_FLOAT_MAT2x4:
return 2;
case GL_INT_VEC3:
case GL_UNSIGNED_INT_VEC3:
case GL_FLOAT_VEC3:
case GL_BOOL_VEC3:
case GL_FLOAT_MAT3:
case GL_FLOAT_MAT3x2:
case GL_FLOAT_MAT3x4:
return 3;
case GL_BOOL_VEC4:
case GL_FLOAT_VEC4:
case GL_INT_VEC4:
case GL_UNSIGNED_INT_VEC4:
case GL_FLOAT_MAT4:
case GL_FLOAT_MAT4x2:
case GL_FLOAT_MAT4x3:
return 4;
default:
UNREACHABLE(type);
}
return 0;
}
int VariableRegisterCount(GLenum type)
{
// Number of registers used is the number of columns for matrices or 1 for scalars and vectors
return (VariableRowCount(type) > 1) ? VariableColumnCount(type) : 1;
}
int VariableRegisterSize(GLenum type)
{
// Number of components per register is the number of rows for matrices or columns for scalars and vectors
int nbRows = VariableRowCount(type);
return (nbRows > 1) ? nbRows : VariableColumnCount(type);
}
int AllocateFirstFreeBits(unsigned int *bits, unsigned int allocationSize, unsigned int bitsSize)
{
ASSERT(allocationSize <= bitsSize);
unsigned int mask = std::numeric_limits<unsigned int>::max() >> (std::numeric_limits<unsigned int>::digits - allocationSize);
for(unsigned int i = 0; i < bitsSize - allocationSize + 1; i++)
{
if((*bits & mask) == 0)
{
*bits |= mask;
return i;
}
mask <<= 1;
}
return -1;
}
bool IsCompressed(GLint internalformat, GLint clientVersion)
{
switch(internalformat)
{
case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE:
case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE:
case GL_ETC1_RGB8_OES:
return true;
case GL_COMPRESSED_R11_EAC:
case GL_COMPRESSED_SIGNED_R11_EAC:
case GL_COMPRESSED_RG11_EAC:
case GL_COMPRESSED_SIGNED_RG11_EAC:
case GL_COMPRESSED_RGB8_ETC2:
case GL_COMPRESSED_SRGB8_ETC2:
case GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2:
case GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2:
case GL_COMPRESSED_RGBA8_ETC2_EAC:
case GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC:
return (clientVersion >= 3);
case GL_COMPRESSED_RGBA_ASTC_4x4_KHR:
case GL_COMPRESSED_RGBA_ASTC_5x4_KHR:
case GL_COMPRESSED_RGBA_ASTC_5x5_KHR:
case GL_COMPRESSED_RGBA_ASTC_6x5_KHR:
case GL_COMPRESSED_RGBA_ASTC_6x6_KHR:
case GL_COMPRESSED_RGBA_ASTC_8x5_KHR:
case GL_COMPRESSED_RGBA_ASTC_8x6_KHR:
case GL_COMPRESSED_RGBA_ASTC_8x8_KHR:
case GL_COMPRESSED_RGBA_ASTC_10x5_KHR:
case GL_COMPRESSED_RGBA_ASTC_10x6_KHR:
case GL_COMPRESSED_RGBA_ASTC_10x8_KHR:
case GL_COMPRESSED_RGBA_ASTC_10x10_KHR:
case GL_COMPRESSED_RGBA_ASTC_12x10_KHR:
case GL_COMPRESSED_RGBA_ASTC_12x12_KHR:
case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR:
case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR:
case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR:
case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR:
case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR:
case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR:
case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR:
case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR:
case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR:
case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR:
case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR:
case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR:
case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR:
case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR:
return ASTC_SUPPORT && (clientVersion >= 3);
default:
return false;
}
}
bool IsSizedInternalFormat(GLint internalformat)
{
switch(internalformat)
{
case GL_ALPHA8_EXT:
case GL_LUMINANCE8_EXT:
case GL_LUMINANCE8_ALPHA8_EXT:
case GL_ALPHA32F_EXT:
case GL_LUMINANCE32F_EXT:
case GL_LUMINANCE_ALPHA32F_EXT:
case GL_ALPHA16F_EXT:
case GL_LUMINANCE16F_EXT:
case GL_LUMINANCE_ALPHA16F_EXT:
case GL_R8:
case GL_R8UI:
case GL_R8I:
case GL_R16UI:
case GL_R16I:
case GL_R32UI:
case GL_R32I:
case GL_RG8:
case GL_RG8UI:
case GL_RG8I:
case GL_RG16UI:
case GL_RG16I:
case GL_RG32UI:
case GL_RG32I:
case GL_SRGB8_ALPHA8:
case GL_RGB8UI:
case GL_RGB8I:
case GL_RGB16UI:
case GL_RGB16I:
case GL_RGB32UI:
case GL_RGB32I:
case GL_RG8_SNORM:
case GL_R8_SNORM:
case GL_RGB10_A2:
case GL_RGBA8UI:
case GL_RGBA8I:
case GL_RGB10_A2UI:
case GL_RGBA16UI:
case GL_RGBA16I:
case GL_RGBA32I:
case GL_RGBA32UI:
case GL_RGBA4:
case GL_RGB5_A1:
case GL_RGB565:
case GL_RGB8:
case GL_RGBA8:
case GL_BGRA8_EXT: // GL_APPLE_texture_format_BGRA8888
case GL_R16F:
case GL_RG16F:
case GL_R11F_G11F_B10F:
case GL_RGB16F:
case GL_RGBA16F:
case GL_R32F:
case GL_RG32F:
case GL_RGB32F:
case GL_RGBA32F:
case GL_DEPTH_COMPONENT24:
case GL_DEPTH_COMPONENT32_OES:
case GL_DEPTH_COMPONENT32F:
case GL_DEPTH32F_STENCIL8:
case GL_DEPTH_COMPONENT16:
case GL_STENCIL_INDEX8:
case GL_DEPTH24_STENCIL8_OES:
case GL_RGBA8_SNORM:
case GL_SRGB8:
case GL_RGB8_SNORM:
case GL_RGB9_E5:
return true;
default:
return false;
}
}
GLenum ValidateSubImageParams(bool compressed, bool copy, GLenum target, GLint level, GLint xoffset, GLint yoffset,
GLsizei width, GLsizei height, GLenum format, GLenum type, Texture *texture, GLint clientVersion)
{
if(!texture)
{
return GL_INVALID_OPERATION;
}
GLenum sizedInternalFormat = texture->getFormat(target, level);
if(compressed)
{
if(format != sizedInternalFormat)
{
return GL_INVALID_OPERATION;
}
}
else if(!copy) // CopyTexSubImage doesn't have format/type parameters.
{
GLenum validationError = ValidateTextureFormatType(format, type, sizedInternalFormat, target, clientVersion);
if(validationError != GL_NO_ERROR)
{
return validationError;
}
}
if(compressed)
{
if((width % 4 != 0 && width != texture->getWidth(target, 0)) ||
(height % 4 != 0 && height != texture->getHeight(target, 0)))
{
return GL_INVALID_OPERATION;
}
}
if(xoffset + width > texture->getWidth(target, level) ||
yoffset + height > texture->getHeight(target, level))
{
return GL_INVALID_VALUE;
}
return GL_NO_ERROR;
}
GLenum ValidateSubImageParams(bool compressed, bool copy, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset,
GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, Texture *texture, GLint clientVersion)
{
if(!texture)
{
return GL_INVALID_OPERATION;
}
if(compressed != texture->isCompressed(target, level))
{
return GL_INVALID_OPERATION;
}
if(!copy)
{
GLenum sizedInternalFormat = texture->getFormat(target, level);
GLenum validationError = ValidateTextureFormatType(format, type, sizedInternalFormat, target, clientVersion);
if(validationError != GL_NO_ERROR)
{
return validationError;
}
}
if(compressed)
{
if((width % 4 != 0 && width != texture->getWidth(target, 0)) ||
(height % 4 != 0 && height != texture->getHeight(target, 0)) ||
(depth % 4 != 0 && depth != texture->getDepth(target, 0)))
{
return GL_INVALID_OPERATION;
}
}
if(xoffset + width > texture->getWidth(target, level) ||
yoffset + height > texture->getHeight(target, level) ||
zoffset + depth > texture->getDepth(target, level))
{
return GL_INVALID_VALUE;
}
return GL_NO_ERROR;
}
bool ValidateCopyFormats(GLenum textureFormat, GLenum colorbufferFormat)
{
ASSERT(!gl::IsUnsizedInternalFormat(textureFormat));
ASSERT(!gl::IsUnsizedInternalFormat(colorbufferFormat));
if(GetColorComponentType(textureFormat) == GL_NONE)
{
return error(GL_INVALID_ENUM, false);
}
if(GetColorComponentType(colorbufferFormat) != GetColorComponentType(textureFormat))
{
return error(GL_INVALID_OPERATION, false);
}
if(GetColorEncoding(colorbufferFormat) != GetColorEncoding(textureFormat))
{
return error(GL_INVALID_OPERATION, false);
}
GLenum baseTexureFormat = gl::GetBaseInternalFormat(textureFormat);
GLenum baseColorbufferFormat = gl::GetBaseInternalFormat(colorbufferFormat);
// [OpenGL ES 2.0.24] table 3.9
// [OpenGL ES 3.0.5] table 3.16
switch(baseTexureFormat)
{
case GL_ALPHA:
if(baseColorbufferFormat != GL_ALPHA &&
baseColorbufferFormat != GL_RGBA &&
baseColorbufferFormat != GL_BGRA_EXT) // GL_EXT_texture_format_BGRA8888 / GL_APPLE_texture_format_BGRA8888
{
return error(GL_INVALID_OPERATION, false);
}
break;
case GL_LUMINANCE_ALPHA:
case GL_RGBA:
if(baseColorbufferFormat != GL_RGBA &&
baseColorbufferFormat != GL_BGRA_EXT) // GL_EXT_texture_format_BGRA8888 / GL_APPLE_texture_format_BGRA8888
{
return error(GL_INVALID_OPERATION, false);
}
break;
case GL_LUMINANCE:
case GL_RED:
if(baseColorbufferFormat != GL_RED &&
baseColorbufferFormat != GL_RG &&
baseColorbufferFormat != GL_RGB &&
baseColorbufferFormat != GL_RGBA &&
baseColorbufferFormat != GL_BGRA_EXT) // GL_EXT_texture_format_BGRA8888 / GL_APPLE_texture_format_BGRA8888
{
return error(GL_INVALID_OPERATION, false);
}
break;
case GL_RG:
if(baseColorbufferFormat != GL_RG &&
baseColorbufferFormat != GL_RGB &&
baseColorbufferFormat != GL_RGBA &&
baseColorbufferFormat != GL_BGRA_EXT) // GL_EXT_texture_format_BGRA8888 / GL_APPLE_texture_format_BGRA8888
{
return error(GL_INVALID_OPERATION, false);
}
break;
case GL_RGB:
if(baseColorbufferFormat != GL_RGB &&
baseColorbufferFormat != GL_RGBA &&
baseColorbufferFormat != GL_BGRA_EXT) // GL_EXT_texture_format_BGRA8888 / GL_APPLE_texture_format_BGRA8888
{
return error(GL_INVALID_OPERATION, false);
}
break;
case GL_DEPTH_COMPONENT:
case GL_DEPTH_STENCIL_OES:
return error(GL_INVALID_OPERATION, false);
case GL_BGRA_EXT: // GL_EXT_texture_format_BGRA8888 nor GL_APPLE_texture_format_BGRA8888 mention the format to be accepted by glCopyTexImage2D.
default:
return error(GL_INVALID_ENUM, false);
}
return true;
}
bool IsValidReadPixelsFormatType(const Framebuffer *framebuffer, GLenum format, GLenum type, GLint clientVersion)
{
// GL_NV_read_depth
if(format == GL_DEPTH_COMPONENT)
{
Renderbuffer *depthbuffer = framebuffer->getDepthbuffer();
if(!depthbuffer)
{
return false;
}
switch(type)
{
case GL_UNSIGNED_SHORT:
case GL_FLOAT:
return true;
default:
UNIMPLEMENTED();
return false;
}
}
Renderbuffer *colorbuffer = framebuffer->getReadColorbuffer();
if(!colorbuffer)
{
return false;
}
GLint internalformat = colorbuffer->getFormat();
if(IsNormalizedInteger(internalformat))
{
// Combination always supported by normalized fixed-point rendering surfaces.
if(format == GL_RGBA && type == GL_UNSIGNED_BYTE)
{
return true;
}
// GL_EXT_read_format_bgra combinations.
if(format == GL_BGRA_EXT)
{
if(type == GL_UNSIGNED_BYTE ||
type == GL_UNSIGNED_SHORT_4_4_4_4_REV_EXT ||
type == GL_UNSIGNED_SHORT_1_5_5_5_REV_EXT)
{
return true;
}
}
}
else if(IsFloatFormat(internalformat))
{
// Combination always supported by floating-point rendering surfaces.
// Supported in OpenGL ES 2.0 due to GL_EXT_color_buffer_half_float.
if(format == GL_RGBA && type == GL_FLOAT)
{
return true;
}
}
else if(IsSignedNonNormalizedInteger(internalformat))
{
ASSERT(clientVersion >= 3);
if(format == GL_RGBA_INTEGER && type == GL_INT)
{
return true;
}
}
else if(IsUnsignedNonNormalizedInteger(internalformat))
{
ASSERT(clientVersion >= 3);
if(format == GL_RGBA_INTEGER && type == GL_UNSIGNED_INT)
{
return true;
}
}
else UNREACHABLE(internalformat);
// GL_IMPLEMENTATION_COLOR_READ_FORMAT / GL_IMPLEMENTATION_COLOR_READ_TYPE
GLenum implementationReadFormat = GL_NONE;
GLenum implementationReadType = GL_NONE;
switch(format)
{
default:
implementationReadFormat = framebuffer->getImplementationColorReadFormat();
implementationReadType = framebuffer->getImplementationColorReadType();
break;
case GL_DEPTH_COMPONENT:
implementationReadFormat = framebuffer->getDepthReadFormat();
implementationReadType = framebuffer->getDepthReadType();
break;
}
if(format == implementationReadFormat && type == implementationReadType)
{
return true;
}
// Additional third combination accepted by OpenGL ES 3.0.
if(internalformat == GL_RGB10_A2)
{
ASSERT(clientVersion >= 3);
if(format == GL_RGBA && type == GL_UNSIGNED_INT_2_10_10_10_REV)
{
return true;
}
}
return false;
}
bool IsDepthTexture(GLenum format)
{
return format == GL_DEPTH_COMPONENT ||
format == GL_DEPTH_STENCIL_OES ||
format == GL_DEPTH_COMPONENT16 ||
format == GL_DEPTH_COMPONENT24 ||
format == GL_DEPTH_COMPONENT32_OES ||
format == GL_DEPTH_COMPONENT32F ||
format == GL_DEPTH24_STENCIL8 ||
format == GL_DEPTH32F_STENCIL8;
}
bool IsStencilTexture(GLenum format)
{
return format == GL_STENCIL_INDEX_OES ||
format == GL_DEPTH_STENCIL_OES ||
format == GL_DEPTH24_STENCIL8 ||
format == GL_DEPTH32F_STENCIL8;
}
bool IsCubemapTextureTarget(GLenum target)
{
return (target >= GL_TEXTURE_CUBE_MAP_POSITIVE_X && target <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z);
}
int CubeFaceIndex(GLenum cubeFace)
{
switch(cubeFace)
{
case GL_TEXTURE_CUBE_MAP:
case GL_TEXTURE_CUBE_MAP_POSITIVE_X: return 0;
case GL_TEXTURE_CUBE_MAP_NEGATIVE_X: return 1;
case GL_TEXTURE_CUBE_MAP_POSITIVE_Y: return 2;
case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y: return 3;
case GL_TEXTURE_CUBE_MAP_POSITIVE_Z: return 4;
case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z: return 5;
default: UNREACHABLE(cubeFace); return 0;
}
}
bool IsTextureTarget(GLenum target)
{
return target == GL_TEXTURE_2D || IsCubemapTextureTarget(target) || target == GL_TEXTURE_3D || target == GL_TEXTURE_2D_ARRAY || target == GL_TEXTURE_RECTANGLE_ARB;
}
GLenum ValidateTextureFormatType(GLenum format, GLenum type, GLint internalformat, GLenum target, GLint clientVersion)
{
switch(type)
{
case GL_UNSIGNED_BYTE:
case GL_UNSIGNED_SHORT_4_4_4_4:
case GL_UNSIGNED_SHORT_5_5_5_1:
case GL_UNSIGNED_SHORT_5_6_5:
case GL_FLOAT: // GL_OES_texture_float
case GL_HALF_FLOAT_OES: // GL_OES_texture_half_float
case GL_HALF_FLOAT:
case GL_UNSIGNED_INT_24_8: // GL_OES_packed_depth_stencil (GL_UNSIGNED_INT_24_8_EXT)
case GL_UNSIGNED_SHORT: // GL_OES_depth_texture
case GL_UNSIGNED_INT: // GL_OES_depth_texture
break;
case GL_BYTE:
case GL_SHORT:
case GL_INT:
case GL_UNSIGNED_INT_2_10_10_10_REV:
case GL_UNSIGNED_INT_10F_11F_11F_REV:
case GL_UNSIGNED_INT_5_9_9_9_REV:
case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
if(clientVersion < 3)
{
return GL_INVALID_ENUM;
}
break;
default:
return GL_INVALID_ENUM;
}
switch(format)
{
case GL_ALPHA:
case GL_RGB:
case GL_RGBA:
case GL_LUMINANCE:
case GL_LUMINANCE_ALPHA:
case GL_BGRA_EXT: // GL_EXT_texture_format_BGRA8888
case GL_RED_EXT: // GL_EXT_texture_rg
case GL_RG_EXT: // GL_EXT_texture_rg
break;
case GL_DEPTH_STENCIL: // GL_OES_packed_depth_stencil (GL_DEPTH_STENCIL_OES)
case GL_DEPTH_COMPONENT: // GL_OES_depth_texture
switch(target)
{
case GL_TEXTURE_2D:
case GL_TEXTURE_2D_ARRAY:
case GL_TEXTURE_CUBE_MAP_POSITIVE_X: // GL_OES_depth_texture_cube_map
case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
break;
default:
return GL_INVALID_OPERATION;
}
break;
case GL_RED_INTEGER:
case GL_RG_INTEGER:
case GL_RGB_INTEGER:
case GL_RGBA_INTEGER:
if(clientVersion < 3)
{
return GL_INVALID_ENUM;
}
break;
default:
return GL_INVALID_ENUM;
}
if((GLenum)internalformat != format)
{
if(gl::IsUnsizedInternalFormat(internalformat))
{
return GL_INVALID_OPERATION;
}
if(!IsSizedInternalFormat(internalformat))
{
return GL_INVALID_VALUE;
}
}
if((GLenum)internalformat == format)
{
// Validate format, type, and unsized internalformat combinations [OpenGL ES 3.0 Table 3.3]
switch(format)
{
case GL_RGBA:
switch(type)
{
case GL_UNSIGNED_BYTE:
case GL_UNSIGNED_SHORT_4_4_4_4:
case GL_UNSIGNED_SHORT_5_5_5_1:
case GL_FLOAT: // GL_OES_texture_float
case GL_HALF_FLOAT_OES: // GL_OES_texture_half_float
break;
default:
return GL_INVALID_OPERATION;
}
break;
case GL_RGB:
switch(type)
{
case GL_UNSIGNED_BYTE:
case GL_UNSIGNED_SHORT_5_6_5:
case GL_FLOAT: // GL_OES_texture_float
case GL_HALF_FLOAT_OES: // GL_OES_texture_half_float
break;
default:
return GL_INVALID_OPERATION;
}
break;
case GL_LUMINANCE_ALPHA:
case GL_LUMINANCE:
case GL_ALPHA:
switch(type)
{
case GL_UNSIGNED_BYTE:
case GL_FLOAT: // GL_OES_texture_float
case GL_HALF_FLOAT_OES: // GL_OES_texture_half_float
break;
default:
return GL_INVALID_OPERATION;
}
break;
case GL_DEPTH_COMPONENT:
switch(type)
{
case GL_UNSIGNED_SHORT: // GL_OES_depth_texture
case GL_UNSIGNED_INT: // GL_OES_depth_texture
break;
default:
return GL_INVALID_OPERATION;
}
break;
case GL_DEPTH_STENCIL_OES:
switch(type)
{
case GL_UNSIGNED_INT_24_8_OES: // GL_OES_packed_depth_stencil
break;
default:
return GL_INVALID_OPERATION;
}
break;
case GL_RED_EXT:
case GL_RG_EXT:
switch(type)
{
case GL_UNSIGNED_BYTE: // GL_EXT_texture_rg
case GL_FLOAT: // GL_EXT_texture_rg + GL_OES_texture_float
case GL_HALF_FLOAT_OES: // GL_EXT_texture_rg + GL_OES_texture_half_float
break;
default:
return GL_INVALID_OPERATION;
}
break;
case GL_BGRA_EXT:
if(type != GL_UNSIGNED_BYTE) // GL_APPLE_texture_format_BGRA8888 / GL_EXT_texture_format_BGRA8888
{
return GL_INVALID_OPERATION;
}
break;
default:
UNREACHABLE(format);
return GL_INVALID_ENUM;
}
return GL_NO_ERROR;
}
// Validate format, type, and sized internalformat combinations [OpenGL ES 3.0 Table 3.2]
bool validSizedInternalformat = false;
#define VALIDATE_INTERNALFORMAT(...) { GLint validInternalformats[] = {__VA_ARGS__}; for(GLint v : validInternalformats) {if(internalformat == v) validSizedInternalformat = true;} } break;
switch(format)
{
case GL_RGBA:
switch(type)
{
case GL_UNSIGNED_BYTE: VALIDATE_INTERNALFORMAT(GL_RGBA8, GL_RGB5_A1, GL_RGBA4, GL_SRGB8_ALPHA8)
case GL_BYTE: VALIDATE_INTERNALFORMAT(GL_RGBA8_SNORM)
case GL_UNSIGNED_SHORT_4_4_4_4: VALIDATE_INTERNALFORMAT(GL_RGBA4)
case GL_UNSIGNED_SHORT_5_5_5_1: VALIDATE_INTERNALFORMAT(GL_RGB5_A1)
case GL_UNSIGNED_INT_2_10_10_10_REV: VALIDATE_INTERNALFORMAT(GL_RGB10_A2, GL_RGB5_A1)
case GL_HALF_FLOAT_OES:
case GL_HALF_FLOAT: VALIDATE_INTERNALFORMAT(GL_RGBA16F)
case GL_FLOAT: VALIDATE_INTERNALFORMAT(GL_RGBA32F, GL_RGBA16F)
default: return GL_INVALID_OPERATION;
}
break;
case GL_RGBA_INTEGER:
switch(type)
{
case GL_UNSIGNED_BYTE: VALIDATE_INTERNALFORMAT(GL_RGBA8UI)
case GL_BYTE: VALIDATE_INTERNALFORMAT(GL_RGBA8I)
case GL_UNSIGNED_SHORT: VALIDATE_INTERNALFORMAT(GL_RGBA16UI)
case GL_SHORT: VALIDATE_INTERNALFORMAT(GL_RGBA16I)
case GL_UNSIGNED_INT: VALIDATE_INTERNALFORMAT(GL_RGBA32UI)
case GL_INT: VALIDATE_INTERNALFORMAT(GL_RGBA32I)
case GL_UNSIGNED_INT_2_10_10_10_REV: VALIDATE_INTERNALFORMAT(GL_RGB10_A2UI)
default: return GL_INVALID_OPERATION;
}
break;
case GL_RGB:
switch(type)
{
case GL_UNSIGNED_BYTE: VALIDATE_INTERNALFORMAT(GL_RGB8, GL_RGB565, GL_SRGB8)
case GL_BYTE: VALIDATE_INTERNALFORMAT(GL_RGB8_SNORM)
case GL_UNSIGNED_SHORT_5_6_5: VALIDATE_INTERNALFORMAT(GL_RGB565)
case GL_UNSIGNED_INT_10F_11F_11F_REV: VALIDATE_INTERNALFORMAT(GL_R11F_G11F_B10F)
case GL_UNSIGNED_INT_5_9_9_9_REV: VALIDATE_INTERNALFORMAT(GL_RGB9_E5)
case GL_HALF_FLOAT_OES:
case GL_HALF_FLOAT: VALIDATE_INTERNALFORMAT(GL_RGB16F, GL_R11F_G11F_B10F, GL_RGB9_E5)
case GL_FLOAT: VALIDATE_INTERNALFORMAT(GL_RGB32F, GL_RGB16F, GL_R11F_G11F_B10F, GL_RGB9_E5)
default: return GL_INVALID_OPERATION;
}
break;
case GL_RGB_INTEGER:
switch(type)
{
case GL_UNSIGNED_BYTE: VALIDATE_INTERNALFORMAT(GL_RGB8UI)
case GL_BYTE: VALIDATE_INTERNALFORMAT(GL_RGB8I)
case GL_UNSIGNED_SHORT: VALIDATE_INTERNALFORMAT(GL_RGB16UI)
case GL_SHORT: VALIDATE_INTERNALFORMAT(GL_RGB16I)
case GL_UNSIGNED_INT: VALIDATE_INTERNALFORMAT(GL_RGB32UI)
case GL_INT: VALIDATE_INTERNALFORMAT(GL_RGB32I)
default: return GL_INVALID_OPERATION;
}
break;
case GL_RG:
switch(type)
{
case GL_UNSIGNED_BYTE: VALIDATE_INTERNALFORMAT(GL_RG8)
case GL_BYTE: VALIDATE_INTERNALFORMAT(GL_RG8_SNORM)
case GL_HALF_FLOAT_OES:
case GL_HALF_FLOAT: VALIDATE_INTERNALFORMAT(GL_RG16F)
case GL_FLOAT: VALIDATE_INTERNALFORMAT(GL_RG32F, GL_RG16F)
default: return GL_INVALID_OPERATION;
}
break;
case GL_RG_INTEGER:
switch(type)
{
case GL_UNSIGNED_BYTE: VALIDATE_INTERNALFORMAT(GL_RG8UI)
case GL_BYTE: VALIDATE_INTERNALFORMAT(GL_RG8I)
case GL_UNSIGNED_SHORT: VALIDATE_INTERNALFORMAT(GL_RG16UI)
case GL_SHORT: VALIDATE_INTERNALFORMAT(GL_RG16I)
case GL_UNSIGNED_INT: VALIDATE_INTERNALFORMAT(GL_RG32UI)
case GL_INT: VALIDATE_INTERNALFORMAT(GL_RG32I)
default: return GL_INVALID_OPERATION;
}
break;
case GL_RED:
switch(type)
{
case GL_UNSIGNED_BYTE: VALIDATE_INTERNALFORMAT(GL_R8)
case GL_BYTE: VALIDATE_INTERNALFORMAT(GL_R8_SNORM)
case GL_HALF_FLOAT_OES:
case GL_HALF_FLOAT: VALIDATE_INTERNALFORMAT(GL_R16F)
case GL_FLOAT: VALIDATE_INTERNALFORMAT(GL_R32F, GL_R16F)
default: return GL_INVALID_OPERATION;
}
break;
case GL_RED_INTEGER:
switch(type)
{
case GL_UNSIGNED_BYTE: VALIDATE_INTERNALFORMAT(GL_R8UI)
case GL_BYTE: VALIDATE_INTERNALFORMAT(GL_R8I)
case GL_UNSIGNED_SHORT: VALIDATE_INTERNALFORMAT(GL_R16UI)
case GL_SHORT: VALIDATE_INTERNALFORMAT(GL_R16I)
case GL_UNSIGNED_INT: VALIDATE_INTERNALFORMAT(GL_R32UI)
case GL_INT: VALIDATE_INTERNALFORMAT(GL_R32I)
default: return GL_INVALID_OPERATION;
}
break;
case GL_DEPTH_COMPONENT:
switch(type)
{
case GL_UNSIGNED_SHORT: VALIDATE_INTERNALFORMAT(GL_DEPTH_COMPONENT16)
case GL_UNSIGNED_INT: VALIDATE_INTERNALFORMAT(GL_DEPTH_COMPONENT24, GL_DEPTH_COMPONENT16)
case GL_FLOAT: VALIDATE_INTERNALFORMAT(GL_DEPTH_COMPONENT32F)
default: return GL_INVALID_OPERATION;
}
break;
case GL_DEPTH_STENCIL:
switch(type)
{
case GL_UNSIGNED_INT_24_8: VALIDATE_INTERNALFORMAT(GL_DEPTH24_STENCIL8)
case GL_FLOAT_32_UNSIGNED_INT_24_8_REV: VALIDATE_INTERNALFORMAT(GL_DEPTH32F_STENCIL8)
default: return GL_INVALID_OPERATION;
}
break;
case GL_LUMINANCE_ALPHA:
switch(type)
{
case GL_UNSIGNED_BYTE: VALIDATE_INTERNALFORMAT(GL_LUMINANCE8_ALPHA8_EXT)
case GL_HALF_FLOAT_OES:
case GL_HALF_FLOAT: VALIDATE_INTERNALFORMAT(GL_LUMINANCE_ALPHA16F_EXT)
case GL_FLOAT: VALIDATE_INTERNALFORMAT(GL_LUMINANCE_ALPHA32F_EXT, GL_LUMINANCE_ALPHA16F_EXT)
default:
return GL_INVALID_OPERATION;
}
break;
case GL_LUMINANCE:
switch(type)
{
case GL_UNSIGNED_BYTE: VALIDATE_INTERNALFORMAT(GL_LUMINANCE8_EXT)
case GL_HALF_FLOAT_OES:
case GL_HALF_FLOAT: VALIDATE_INTERNALFORMAT(GL_LUMINANCE16F_EXT)
case GL_FLOAT: VALIDATE_INTERNALFORMAT(GL_LUMINANCE32F_EXT, GL_LUMINANCE16F_EXT)
default:
return GL_INVALID_OPERATION;
}
break;
case GL_ALPHA:
switch(type)
{
case GL_UNSIGNED_BYTE: VALIDATE_INTERNALFORMAT(GL_ALPHA8_EXT)
case GL_HALF_FLOAT_OES:
case GL_HALF_FLOAT: VALIDATE_INTERNALFORMAT(GL_ALPHA16F_EXT)
case GL_FLOAT: VALIDATE_INTERNALFORMAT(GL_ALPHA32F_EXT, GL_ALPHA16F_EXT)
default:
return GL_INVALID_OPERATION;
}
break;
case GL_BGRA_EXT: // GL_APPLE_texture_format_BGRA8888
switch(type)
{
case GL_UNSIGNED_BYTE: VALIDATE_INTERNALFORMAT(GL_BGRA8_EXT)
default: return GL_INVALID_OPERATION;
}
break;
default:
UNREACHABLE(format);
return GL_INVALID_ENUM;
}
#undef VALIDATE_INTERNALFORMAT
if(!validSizedInternalformat)
{
return GL_INVALID_OPERATION;
}
return GL_NO_ERROR;
}
size_t GetTypeSize(GLenum type)
{
switch(type)
{
case GL_BYTE:
case GL_UNSIGNED_BYTE:
return 1;
case GL_UNSIGNED_SHORT_4_4_4_4:
case GL_UNSIGNED_SHORT_5_5_5_1:
case GL_UNSIGNED_SHORT_5_6_5:
case GL_UNSIGNED_SHORT:
case GL_SHORT:
case GL_HALF_FLOAT:
case GL_HALF_FLOAT_OES:
return 2;
case GL_FLOAT:
case GL_UNSIGNED_INT_24_8:
case GL_UNSIGNED_INT:
case GL_INT:
case GL_UNSIGNED_INT_2_10_10_10_REV:
case GL_UNSIGNED_INT_10F_11F_11F_REV:
case GL_UNSIGNED_INT_5_9_9_9_REV:
case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
return 4;
default:
UNREACHABLE(type);
break;
}
return 1;
}
bool IsColorRenderable(GLint internalformat, GLint clientVersion)
{
if(IsCompressed(internalformat, clientVersion))
{
return false;
}
switch(internalformat)
{
case GL_RGBA4:
case GL_RGB5_A1:
case GL_RGB565:
case GL_R8:
case GL_RG8:
case GL_RGB8:
case GL_RGBA8:
case GL_R16F:
case GL_RG16F:
case GL_RGB16F:
case GL_RGBA16F:
case GL_R32F:
case GL_RG32F:
case GL_RGB32F:
case GL_RGBA32F:
case GL_BGRA8_EXT: // GL_EXT_texture_format_BGRA8888
return true;
case GL_R8UI:
case GL_R8I:
case GL_R16UI:
case GL_R16I:
case GL_R32UI:
case GL_R32I:
case GL_RG8UI:
case GL_RG8I:
case GL_RG16UI:
case GL_RG16I:
case GL_RG32UI:
case GL_RG32I:
case GL_SRGB8_ALPHA8:
case GL_RGB10_A2:
case GL_RGBA8UI:
case GL_RGBA8I:
case GL_RGB10_A2UI:
case GL_RGBA16UI:
case GL_RGBA16I:
case GL_RGBA32I:
case GL_RGBA32UI:
case GL_R11F_G11F_B10F:
return clientVersion >= 3;
case GL_R8_SNORM:
case GL_RG8_SNORM:
case GL_RGB8_SNORM:
case GL_RGBA8_SNORM:
case GL_ALPHA8_EXT:
case GL_LUMINANCE8_EXT:
case GL_LUMINANCE8_ALPHA8_EXT:
case GL_ALPHA32F_EXT:
case GL_LUMINANCE32F_EXT:
case GL_LUMINANCE_ALPHA32F_EXT:
case GL_ALPHA16F_EXT:
case GL_LUMINANCE16F_EXT:
case GL_LUMINANCE_ALPHA16F_EXT:
case GL_DEPTH_COMPONENT24:
case GL_DEPTH_COMPONENT32_OES:
case GL_DEPTH_COMPONENT32F:
case GL_DEPTH32F_STENCIL8:
case GL_DEPTH_COMPONENT16:
case GL_STENCIL_INDEX8:
case GL_DEPTH24_STENCIL8_OES:
return false;
default:
UNIMPLEMENTED();
}
return false;
}
bool IsDepthRenderable(GLint internalformat, GLint clientVersion)
{
if(IsCompressed(internalformat, clientVersion))
{
return false;
}
switch(internalformat)
{
case GL_DEPTH_COMPONENT24:
case GL_DEPTH_COMPONENT16:
case GL_DEPTH24_STENCIL8_OES: // GL_OES_packed_depth_stencil
case GL_DEPTH_COMPONENT32_OES: // GL_OES_depth32
return true;
case GL_DEPTH32F_STENCIL8:
case GL_DEPTH_COMPONENT32F:
return clientVersion >= 3;
case GL_STENCIL_INDEX8:
case GL_R8:
case GL_R8UI:
case GL_R8I:
case GL_R16UI:
case GL_R16I:
case GL_R32UI:
case GL_R32I:
case GL_RG8:
case GL_RG8UI:
case GL_RG8I:
case GL_RG16UI:
case GL_RG16I:
case GL_RG32UI:
case GL_RG32I:
case GL_SRGB8_ALPHA8:
case GL_RGB10_A2:
case GL_RGBA8UI:
case GL_RGBA8I:
case GL_RGB10_A2UI:
case GL_RGBA16UI:
case GL_RGBA16I:
case GL_RGBA32I:
case GL_RGBA32UI:
case GL_RGBA4:
case GL_RGB5_A1:
case GL_RGB565:
case GL_RGB8:
case GL_RGBA8:
case GL_RED:
case GL_RG:
case GL_RGB:
case GL_RGBA:
case GL_R16F:
case GL_RG16F:
case GL_R11F_G11F_B10F:
case GL_RGB16F:
case GL_RGBA16F:
case GL_R32F:
case GL_RG32F:
case GL_RGB32F:
case GL_RGBA32F:
case GL_R8_SNORM:
case GL_RG8_SNORM:
case GL_RGB8_SNORM:
case GL_RGBA8_SNORM:
return false;
default:
UNIMPLEMENTED();
}
return false;
}
bool IsStencilRenderable(GLint internalformat, GLint clientVersion)
{
if(IsCompressed(internalformat, clientVersion))
{
return false;
}
switch(internalformat)
{
case GL_STENCIL_INDEX8:
case GL_DEPTH24_STENCIL8_OES:
return true;
case GL_DEPTH32F_STENCIL8:
return clientVersion >= 3;
case GL_R8:
case GL_R8UI:
case GL_R8I:
case GL_R16UI:
case GL_R16I:
case GL_R32UI:
case GL_R32I:
case GL_RG8:
case GL_RG8UI:
case GL_RG8I:
case GL_RG16UI:
case GL_RG16I:
case GL_RG32UI:
case GL_RG32I:
case GL_SRGB8_ALPHA8:
case GL_RGB10_A2:
case GL_RGBA8UI:
case GL_RGBA8I:
case GL_RGB10_A2UI:
case GL_RGBA16UI:
case GL_RGBA16I:
case GL_RGBA32I:
case GL_RGBA32UI:
case GL_RGBA4:
case GL_RGB5_A1:
case GL_RGB565:
case GL_RGB8:
case GL_RGBA8:
case GL_RED:
case GL_RG:
case GL_RGB:
case GL_RGBA:
case GL_R16F:
case GL_RG16F:
case GL_R11F_G11F_B10F:
case GL_RGB16F:
case GL_RGBA16F:
case GL_R32F:
case GL_RG32F:
case GL_RGB32F:
case GL_RGBA32F:
case GL_DEPTH_COMPONENT16:
case GL_DEPTH_COMPONENT24:
case GL_DEPTH_COMPONENT32_OES:
case GL_DEPTH_COMPONENT32F:
case GL_R8_SNORM:
case GL_RG8_SNORM:
case GL_RGB8_SNORM:
case GL_RGBA8_SNORM:
return false;
default:
UNIMPLEMENTED();
}
return false;
}
bool IsMipmappable(GLint internalformat, GLint clientVersion)
{
if(IsNonNormalizedInteger(internalformat))
{
return false;
}
switch(internalformat)
{
case GL_ALPHA8_EXT:
case GL_LUMINANCE8_EXT:
case GL_LUMINANCE8_ALPHA8_EXT:
case GL_ALPHA32F_EXT:
case GL_LUMINANCE32F_EXT:
case GL_LUMINANCE_ALPHA32F_EXT:
case GL_ALPHA16F_EXT:
case GL_LUMINANCE16F_EXT:
case GL_LUMINANCE_ALPHA16F_EXT:
return true;
default:
return IsColorRenderable(internalformat, clientVersion);
}
}
GLuint GetAlphaSize(GLint internalformat)
{
switch(internalformat)
{
case GL_NONE: return 0;
case GL_RGBA4: return 4;
case GL_RGB5_A1: return 1;
case GL_RGB565: return 0;
case GL_R8: return 0;
case GL_RG8: return 0;
case GL_RGB8: return 0;
case GL_RGBA8: return 8;
case GL_R16F: return 0;
case GL_RG16F: return 0;
case GL_RGB16F: return 0;
case GL_RGBA16F: return 16;
case GL_R32F: return 0;
case GL_RG32F: return 0;
case GL_RGB32F: return 0;
case GL_RGBA32F: return 32;
case GL_BGRA8_EXT: return 8;
case GL_R8UI: return 0;
case GL_R8I: return 0;
case GL_R16UI: return 0;
case GL_R16I: return 0;
case GL_R32UI: return 0;
case GL_R32I: return 0;
case GL_RG8UI: return 0;
case GL_RG8I: return 0;
case GL_RG16UI: return 0;
case GL_RG16I: return 0;
case GL_RG32UI: return 0;
case GL_RG32I: return 0;
case GL_SRGB8_ALPHA8: return 8;
case GL_RGB10_A2: return 2;
case GL_RGBA8UI: return 8;
case GL_RGBA8I: return 8;
case GL_RGB10_A2UI: return 2;
case GL_RGBA16UI: return 16;
case GL_RGBA16I: return 16;
case GL_RGBA32I: return 32;
case GL_RGBA32UI: return 32;
case GL_R11F_G11F_B10F: return 0;
default:
// UNREACHABLE(internalformat);
return 0;
}
}
GLuint GetRedSize(GLint internalformat)
{
switch(internalformat)
{
case GL_NONE: return 0;
case GL_RGBA4: return 4;
case GL_RGB5_A1: return 5;
case GL_RGB565: return 5;
case GL_R8: return 8;
case GL_RG8: return 8;
case GL_RGB8: return 8;
case GL_RGBA8: return 8;
case GL_R16F: return 16;
case GL_RG16F: return 16;
case GL_RGB16F: return 16;
case GL_RGBA16F: return 16;
case GL_R32F: return 32;
case GL_RG32F: return 32;
case GL_RGB32F: return 32;
case GL_RGBA32F: return 32;
case GL_BGRA8_EXT: return 8;
case GL_R8UI: return 8;
case GL_R8I: return 8;
case GL_R16UI: return 16;
case GL_R16I: return 16;
case GL_R32UI: return 32;
case GL_R32I: return 32;
case GL_RG8UI: return 8;
case GL_RG8I: return 8;
case GL_RG16UI: return 16;
case GL_RG16I: return 16;
case GL_RG32UI: return 32;
case GL_RG32I: return 32;
case GL_SRGB8_ALPHA8: return 8;
case GL_RGB10_A2: return 10;
case GL_RGBA8UI: return 8;
case GL_RGBA8I: return 8;
case GL_RGB10_A2UI: return 10;
case GL_RGBA16UI: return 16;
case GL_RGBA16I: return 16;
case GL_RGBA32I: return 32;
case GL_RGBA32UI: return 32;
case GL_R11F_G11F_B10F: return 11;
default:
// UNREACHABLE(internalformat);
return 0;
}
}
GLuint GetGreenSize(GLint internalformat)
{
switch(internalformat)
{
case GL_NONE: return 0;
case GL_RGBA4: return 4;
case GL_RGB5_A1: return 5;
case GL_RGB565: return 6;
case GL_R8: return 0;
case GL_RG8: return 8;
case GL_RGB8: return 8;
case GL_RGBA8: return 8;
case GL_R16F: return 0;
case GL_RG16F: return 16;
case GL_RGB16F: return 16;
case GL_RGBA16F: return 16;
case GL_R32F: return 0;
case GL_RG32F: return 32;
case GL_RGB32F: return 32;
case GL_RGBA32F: return 32;
case GL_BGRA8_EXT: return 8;
case GL_R8UI: return 0;
case GL_R8I: return 0;
case GL_R16UI: return 0;
case GL_R16I: return 0;
case GL_R32UI: return 0;
case GL_R32I: return 0;
case GL_RG8UI: return 8;
case GL_RG8I: return 8;
case GL_RG16UI: return 16;
case GL_RG16I: return 16;
case GL_RG32UI: return 32;
case GL_RG32I: return 32;
case GL_SRGB8_ALPHA8: return 8;
case GL_RGB10_A2: return 10;
case GL_RGBA8UI: return 8;
case GL_RGBA8I: return 8;
case GL_RGB10_A2UI: return 10;
case GL_RGBA16UI: return 16;
case GL_RGBA16I: return 16;
case GL_RGBA32I: return 32;
case GL_RGBA32UI: return 32;
case GL_R11F_G11F_B10F: return 11;
default:
// UNREACHABLE(internalformat);
return 0;
}
}
GLuint GetBlueSize(GLint internalformat)
{
switch(internalformat)
{
case GL_NONE: return 0;
case GL_RGBA4: return 4;
case GL_RGB5_A1: return 5;
case GL_RGB565: return 5;
case GL_R8: return 0;
case GL_RG8: return 0;
case GL_RGB8: return 8;
case GL_RGBA8: return 8;
case GL_R16F: return 0;
case GL_RG16F: return 0;
case GL_RGB16F: return 16;
case GL_RGBA16F: return 16;
case GL_R32F: return 0;
case GL_RG32F: return 0;
case GL_RGB32F: return 32;
case GL_RGBA32F: return 32;
case GL_BGRA8_EXT: return 8;
case GL_R8UI: return 0;
case GL_R8I: return 0;
case GL_R16UI: return 0;
case GL_R16I: return 0;
case GL_R32UI: return 0;
case GL_R32I: return 0;
case GL_RG8UI: return 0;
case GL_RG8I: return 0;
case GL_RG16UI: return 0;
case GL_RG16I: return 0;
case GL_RG32UI: return 0;
case GL_RG32I: return 0;
case GL_SRGB8_ALPHA8: return 8;
case GL_RGB10_A2: return 10;
case GL_RGBA8UI: return 8;
case GL_RGBA8I: return 8;
case GL_RGB10_A2UI: return 10;
case GL_RGBA16UI: return 16;
case GL_RGBA16I: return 16;
case GL_RGBA32I: return 32;
case GL_RGBA32UI: return 32;
case GL_R11F_G11F_B10F: return 10;
default:
// UNREACHABLE(internalformat);
return 0;
}
}
GLuint GetDepthSize(GLint internalformat)
{
switch(internalformat)
{
case GL_STENCIL_INDEX8: return 0;
case GL_DEPTH_COMPONENT16: return 16;
case GL_DEPTH_COMPONENT24: return 24;
case GL_DEPTH_COMPONENT32_OES: return 32;
case GL_DEPTH_COMPONENT32F: return 32;
case GL_DEPTH24_STENCIL8: return 24;
case GL_DEPTH32F_STENCIL8: return 32;
default:
// UNREACHABLE(internalformat);
return 0;
}
}
GLuint GetStencilSize(GLint internalformat)
{
switch(internalformat)
{
case GL_STENCIL_INDEX8: return 8;
case GL_DEPTH_COMPONENT16: return 0;
case GL_DEPTH_COMPONENT24: return 0;
case GL_DEPTH_COMPONENT32_OES: return 0;
case GL_DEPTH_COMPONENT32F: return 0;
case GL_DEPTH24_STENCIL8: return 8;
case GL_DEPTH32F_STENCIL8: return 8;
default:
// UNREACHABLE(internalformat);
return 0;
}
}
GLenum GetColorComponentType(GLint internalformat)
{
switch(internalformat)
{
case GL_ALPHA8_EXT:
case GL_LUMINANCE8_ALPHA8_EXT:
case GL_LUMINANCE8_EXT:
case GL_R8:
case GL_RG8:
case GL_SRGB8_ALPHA8:
case GL_RGB10_A2:
case GL_RGBA4:
case GL_RGB5_A1:
case GL_RGB565:
case GL_RGB8:
case GL_RGBA8:
case GL_SRGB8:
case GL_BGRA8_EXT:
return GL_UNSIGNED_NORMALIZED;
case GL_R8_SNORM:
case GL_RG8_SNORM:
case GL_RGB8_SNORM:
case GL_RGBA8_SNORM:
return GL_SIGNED_NORMALIZED;
case GL_R8UI:
case GL_R16UI:
case GL_R32UI:
case GL_RG8UI:
case GL_RG16UI:
case GL_RG32UI:
case GL_RGB8UI:
case GL_RGB16UI:
case GL_RGB32UI:
case GL_RGB10_A2UI:
case GL_RGBA16UI:
case GL_RGBA32UI:
case GL_RGBA8UI:
return GL_UNSIGNED_INT;
case GL_R8I:
case GL_R16I:
case GL_R32I:
case GL_RG8I:
case GL_RG16I:
case GL_RG32I:
case GL_RGB8I:
case GL_RGB16I:
case GL_RGB32I:
case GL_RGBA8I:
case GL_RGBA16I:
case GL_RGBA32I:
return GL_INT;
case GL_ALPHA32F_EXT:
case GL_LUMINANCE32F_EXT:
case GL_LUMINANCE_ALPHA32F_EXT:
case GL_ALPHA16F_EXT:
case GL_LUMINANCE16F_EXT:
case GL_LUMINANCE_ALPHA16F_EXT:
case GL_R16F:
case GL_RG16F:
case GL_R11F_G11F_B10F:
case GL_RGB16F:
case GL_RGBA16F:
case GL_R32F:
case GL_RG32F:
case GL_RGB32F:
case GL_RGBA32F:
case GL_RGB9_E5:
return GL_FLOAT;
default:
// UNREACHABLE(internalformat);
return GL_NONE;
}
}
GLenum GetComponentType(GLint internalformat, GLenum attachment)
{
// Can be one of GL_FLOAT, GL_INT, GL_UNSIGNED_INT, GL_SIGNED_NORMALIZED, or GL_UNSIGNED_NORMALIZED
switch(attachment)
{
case GL_COLOR_ATTACHMENT0:
case GL_COLOR_ATTACHMENT1:
case GL_COLOR_ATTACHMENT2:
case GL_COLOR_ATTACHMENT3:
case GL_COLOR_ATTACHMENT4:
case GL_COLOR_ATTACHMENT5:
case GL_COLOR_ATTACHMENT6:
case GL_COLOR_ATTACHMENT7:
case GL_COLOR_ATTACHMENT8:
case GL_COLOR_ATTACHMENT9:
case GL_COLOR_ATTACHMENT10:
case GL_COLOR_ATTACHMENT11:
case GL_COLOR_ATTACHMENT12:
case GL_COLOR_ATTACHMENT13:
case GL_COLOR_ATTACHMENT14:
case GL_COLOR_ATTACHMENT15:
case GL_COLOR_ATTACHMENT16:
case GL_COLOR_ATTACHMENT17:
case GL_COLOR_ATTACHMENT18:
case GL_COLOR_ATTACHMENT19:
case GL_COLOR_ATTACHMENT20:
case GL_COLOR_ATTACHMENT21:
case GL_COLOR_ATTACHMENT22:
case GL_COLOR_ATTACHMENT23:
case GL_COLOR_ATTACHMENT24:
case GL_COLOR_ATTACHMENT25:
case GL_COLOR_ATTACHMENT26:
case GL_COLOR_ATTACHMENT27:
case GL_COLOR_ATTACHMENT28:
case GL_COLOR_ATTACHMENT29:
case GL_COLOR_ATTACHMENT30:
case GL_COLOR_ATTACHMENT31:
return GetColorComponentType(internalformat);
case GL_DEPTH_ATTACHMENT:
case GL_STENCIL_ATTACHMENT:
// Only color buffers may have integer components.
return GL_FLOAT;
default:
UNREACHABLE(attachment);
return GL_NONE;
}
}
bool IsNormalizedInteger(GLint internalformat)
{
GLenum type = GetColorComponentType(internalformat);
return type == GL_UNSIGNED_NORMALIZED || type == GL_SIGNED_NORMALIZED;
}
bool IsNonNormalizedInteger(GLint internalformat)
{
GLenum type = GetColorComponentType(internalformat);
return type == GL_UNSIGNED_INT || type == GL_INT;
}
bool IsFloatFormat(GLint internalformat)
{
return GetColorComponentType(internalformat) == GL_FLOAT;
}
bool IsSignedNonNormalizedInteger(GLint internalformat)
{
return GetColorComponentType(internalformat) == GL_INT;
}
bool IsUnsignedNonNormalizedInteger(GLint internalformat)
{
return GetColorComponentType(internalformat) == GL_UNSIGNED_INT;
}
GLenum GetColorEncoding(GLint internalformat)
{
switch(internalformat)
{
case GL_SRGB8:
case GL_SRGB8_ALPHA8:
return GL_SRGB;
default:
// [OpenGL ES 3.0.5] section 6.1.13 page 242:
// If attachment is not a color attachment, or no data storage or texture image
// has been specified for the attachment, params will contain the value LINEAR.
return GL_LINEAR;
}
}
std::string ParseUniformName(const std::string &name, unsigned int *outSubscript)
{
// Strip any trailing array operator and retrieve the subscript
size_t open = name.find_last_of('[');
size_t close = name.find_last_of(']');
bool hasIndex = (open != std::string::npos) && (close == name.length() - 1);
if(!hasIndex)
{
if(outSubscript)
{
*outSubscript = GL_INVALID_INDEX;
}
return name;
}
if(outSubscript)
{
int index = atoi(name.substr(open + 1).c_str());
if(index >= 0)
{
*outSubscript = index;
}
else
{
*outSubscript = GL_INVALID_INDEX;
}
}
return name.substr(0, open);
}
}
namespace es2sw
{
sw::DepthCompareMode ConvertDepthComparison(GLenum comparison)
{
switch(comparison)
{
case GL_NEVER: return sw::DEPTH_NEVER;
case GL_ALWAYS: return sw::DEPTH_ALWAYS;
case GL_LESS: return sw::DEPTH_LESS;
case GL_LEQUAL: return sw::DEPTH_LESSEQUAL;
case GL_EQUAL: return sw::DEPTH_EQUAL;
case GL_GREATER: return sw::DEPTH_GREATER;
case GL_GEQUAL: return sw::DEPTH_GREATEREQUAL;
case GL_NOTEQUAL: return sw::DEPTH_NOTEQUAL;
default: UNREACHABLE(comparison);
}
return sw::DEPTH_ALWAYS;
}
sw::StencilCompareMode ConvertStencilComparison(GLenum comparison)
{
switch(comparison)
{
case GL_NEVER: return sw::STENCIL_NEVER;
case GL_ALWAYS: return sw::STENCIL_ALWAYS;
case GL_LESS: return sw::STENCIL_LESS;
case GL_LEQUAL: return sw::STENCIL_LESSEQUAL;
case GL_EQUAL: return sw::STENCIL_EQUAL;
case GL_GREATER: return sw::STENCIL_GREATER;
case GL_GEQUAL: return sw::STENCIL_GREATEREQUAL;
case GL_NOTEQUAL: return sw::STENCIL_NOTEQUAL;
default: UNREACHABLE(comparison);
}
return sw::STENCIL_ALWAYS;
}
sw::Color<float> ConvertColor(es2::Color color)
{
return sw::Color<float>(color.red, color.green, color.blue, color.alpha);
}
sw::BlendFactor ConvertBlendFunc(GLenum blend)
{
switch(blend)
{
case GL_ZERO: return sw::BLEND_ZERO;
case GL_ONE: return sw::BLEND_ONE;
case GL_SRC_COLOR: return sw::BLEND_SOURCE;
case GL_ONE_MINUS_SRC_COLOR: return sw::BLEND_INVSOURCE;
case GL_DST_COLOR: return sw::BLEND_DEST;
case GL_ONE_MINUS_DST_COLOR: return sw::BLEND_INVDEST;
case GL_SRC_ALPHA: return sw::BLEND_SOURCEALPHA;
case GL_ONE_MINUS_SRC_ALPHA: return sw::BLEND_INVSOURCEALPHA;
case GL_DST_ALPHA: return sw::BLEND_DESTALPHA;
case GL_ONE_MINUS_DST_ALPHA: return sw::BLEND_INVDESTALPHA;
case GL_CONSTANT_COLOR: return sw::BLEND_CONSTANT;
case GL_ONE_MINUS_CONSTANT_COLOR: return sw::BLEND_INVCONSTANT;
case GL_CONSTANT_ALPHA: return sw::BLEND_CONSTANTALPHA;
case GL_ONE_MINUS_CONSTANT_ALPHA: return sw::BLEND_INVCONSTANTALPHA;
case GL_SRC_ALPHA_SATURATE: return sw::BLEND_SRCALPHASAT;
default: UNREACHABLE(blend);
}
return sw::BLEND_ZERO;
}
sw::BlendOperation ConvertBlendOp(GLenum blendOp)
{
switch(blendOp)
{
case GL_FUNC_ADD: return sw::BLENDOP_ADD;
case GL_FUNC_SUBTRACT: return sw::BLENDOP_SUB;
case GL_FUNC_REVERSE_SUBTRACT: return sw::BLENDOP_INVSUB;
case GL_MIN_EXT: return sw::BLENDOP_MIN;
case GL_MAX_EXT: return sw::BLENDOP_MAX;
default: UNREACHABLE(blendOp);
}
return sw::BLENDOP_ADD;
}
sw::StencilOperation ConvertStencilOp(GLenum stencilOp)
{
switch(stencilOp)
{
case GL_ZERO: return sw::OPERATION_ZERO;
case GL_KEEP: return sw::OPERATION_KEEP;
case GL_REPLACE: return sw::OPERATION_REPLACE;
case GL_INCR: return sw::OPERATION_INCRSAT;
case GL_DECR: return sw::OPERATION_DECRSAT;
case GL_INVERT: return sw::OPERATION_INVERT;
case GL_INCR_WRAP: return sw::OPERATION_INCR;
case GL_DECR_WRAP: return sw::OPERATION_DECR;
default: UNREACHABLE(stencilOp);
}
return sw::OPERATION_KEEP;
}
sw::AddressingMode ConvertTextureWrap(GLenum wrap)
{
switch(wrap)
{
case GL_REPEAT: return sw::ADDRESSING_WRAP;
case GL_CLAMP_TO_EDGE: return sw::ADDRESSING_CLAMP;
case GL_MIRRORED_REPEAT: return sw::ADDRESSING_MIRROR;
default: UNREACHABLE(wrap);
}
return sw::ADDRESSING_WRAP;
}
sw::CompareFunc ConvertCompareFunc(GLenum compareFunc, GLenum compareMode)
{
if(compareMode == GL_COMPARE_REF_TO_TEXTURE)
{
switch(compareFunc)
{
case GL_LEQUAL: return sw::COMPARE_LESSEQUAL;
case GL_GEQUAL: return sw::COMPARE_GREATEREQUAL;
case GL_LESS: return sw::COMPARE_LESS;
case GL_GREATER: return sw::COMPARE_GREATER;
case GL_EQUAL: return sw::COMPARE_EQUAL;
case GL_NOTEQUAL: return sw::COMPARE_NOTEQUAL;
case GL_ALWAYS: return sw::COMPARE_ALWAYS;
case GL_NEVER: return sw::COMPARE_NEVER;
default: UNREACHABLE(compareFunc);
}
}
else if(compareMode == GL_NONE)
{
return sw::COMPARE_BYPASS;
}
else UNREACHABLE(compareMode);
return sw::COMPARE_BYPASS;
};
sw::SwizzleType ConvertSwizzleType(GLenum swizzleType)
{
switch(swizzleType)
{
case GL_RED: return sw::SWIZZLE_RED;
case GL_GREEN: return sw::SWIZZLE_GREEN;
case GL_BLUE: return sw::SWIZZLE_BLUE;
case GL_ALPHA: return sw::SWIZZLE_ALPHA;
case GL_ZERO: return sw::SWIZZLE_ZERO;
case GL_ONE: return sw::SWIZZLE_ONE;
default: UNREACHABLE(swizzleType);
}
return sw::SWIZZLE_RED;
};
sw::CullMode ConvertCullMode(GLenum cullFace, GLenum frontFace)
{
switch(cullFace)
{
case GL_FRONT:
return (frontFace == GL_CCW ? sw::CULL_CLOCKWISE : sw::CULL_COUNTERCLOCKWISE);
case GL_BACK:
return (frontFace == GL_CCW ? sw::CULL_COUNTERCLOCKWISE : sw::CULL_CLOCKWISE);
case GL_FRONT_AND_BACK:
return sw::CULL_NONE; // culling will be handled during draw
default: UNREACHABLE(cullFace);
}
return sw::CULL_COUNTERCLOCKWISE;
}
unsigned int ConvertColorMask(bool red, bool green, bool blue, bool alpha)
{
return (red ? 0x00000001 : 0) |
(green ? 0x00000002 : 0) |
(blue ? 0x00000004 : 0) |
(alpha ? 0x00000008 : 0);
}
sw::MipmapType ConvertMipMapFilter(GLenum minFilter)
{
switch(minFilter)
{
case GL_NEAREST:
case GL_LINEAR:
return sw::MIPMAP_NONE;
case GL_NEAREST_MIPMAP_NEAREST:
case GL_LINEAR_MIPMAP_NEAREST:
return sw::MIPMAP_POINT;
case GL_NEAREST_MIPMAP_LINEAR:
case GL_LINEAR_MIPMAP_LINEAR:
return sw::MIPMAP_LINEAR;
default:
UNREACHABLE(minFilter);
return sw::MIPMAP_NONE;
}
}
sw::FilterType ConvertTextureFilter(GLenum minFilter, GLenum magFilter, float maxAnisotropy)
{
if(maxAnisotropy > 1.0f)
{
return sw::FILTER_ANISOTROPIC;
}
switch(magFilter)
{
case GL_NEAREST:
case GL_LINEAR:
break;
default:
UNREACHABLE(magFilter);
}
switch(minFilter)
{
case GL_NEAREST:
case GL_NEAREST_MIPMAP_NEAREST:
case GL_NEAREST_MIPMAP_LINEAR:
return (magFilter == GL_NEAREST) ? sw::FILTER_POINT : sw::FILTER_MIN_POINT_MAG_LINEAR;
case GL_LINEAR:
case GL_LINEAR_MIPMAP_NEAREST:
case GL_LINEAR_MIPMAP_LINEAR:
return (magFilter == GL_NEAREST) ? sw::FILTER_MIN_LINEAR_MAG_POINT : sw::FILTER_LINEAR;
default:
UNREACHABLE(minFilter);
return sw::FILTER_POINT;
}
}
bool ConvertPrimitiveType(GLenum primitiveType, GLsizei elementCount, GLenum elementType, sw::DrawType &drawType, int &primitiveCount, int &verticesPerPrimitive)
{
switch(primitiveType)
{
case GL_POINTS:
drawType = sw::DRAW_POINTLIST;
primitiveCount = elementCount;
verticesPerPrimitive = 1;
break;
case GL_LINES:
drawType = sw::DRAW_LINELIST;
primitiveCount = elementCount / 2;
verticesPerPrimitive = 2;
break;
case GL_LINE_LOOP:
drawType = sw::DRAW_LINELOOP;
primitiveCount = elementCount;
verticesPerPrimitive = 2;
break;
case GL_LINE_STRIP:
drawType = sw::DRAW_LINESTRIP;
primitiveCount = elementCount - 1;
verticesPerPrimitive = 2;
break;
case GL_TRIANGLES:
drawType = sw::DRAW_TRIANGLELIST;
primitiveCount = elementCount / 3;
verticesPerPrimitive = 3;
break;
case GL_TRIANGLE_STRIP:
drawType = sw::DRAW_TRIANGLESTRIP;
primitiveCount = elementCount - 2;
verticesPerPrimitive = 3;
break;
case GL_TRIANGLE_FAN:
drawType = sw::DRAW_TRIANGLEFAN;
primitiveCount = elementCount - 2;
verticesPerPrimitive = 3;
break;
default:
return false;
}
sw::DrawType elementSize;
switch(elementType)
{
case GL_NONE: elementSize = sw::DRAW_NONINDEXED; break;
case GL_UNSIGNED_BYTE: elementSize = sw::DRAW_INDEXED8; break;
case GL_UNSIGNED_SHORT: elementSize = sw::DRAW_INDEXED16; break;
case GL_UNSIGNED_INT: elementSize = sw::DRAW_INDEXED32; break;
default: return false;
}
drawType = sw::DrawType(drawType | elementSize);
return true;
}
}
namespace sw2es
{
GLenum ConvertBackBufferFormat(sw::Format format)
{
switch(format)
{
case sw::FORMAT_A4R4G4B4: return GL_RGBA4;
case sw::FORMAT_A8R8G8B8: return GL_RGBA8;
case sw::FORMAT_A8B8G8R8: return GL_RGBA8;
case sw::FORMAT_A1R5G5B5: return GL_RGB5_A1;
case sw::FORMAT_R5G6B5: return GL_RGB565;
case sw::FORMAT_X8R8G8B8: return GL_RGB8;
case sw::FORMAT_X8B8G8R8: return GL_RGB8;
case sw::FORMAT_SRGB8_A8: return GL_RGBA8;
case sw::FORMAT_SRGB8_X8: return GL_RGB8;
default:
UNREACHABLE(format);
}
return GL_RGBA4;
}
GLenum ConvertDepthStencilFormat(sw::Format format)
{
switch(format)
{
case sw::FORMAT_D16: return GL_DEPTH_COMPONENT16;
case sw::FORMAT_D24X8: return GL_DEPTH_COMPONENT24;
case sw::FORMAT_D32: return GL_DEPTH_COMPONENT32_OES;
case sw::FORMAT_D24S8: return GL_DEPTH24_STENCIL8_OES;
case sw::FORMAT_D32F: return GL_DEPTH_COMPONENT32F;
case sw::FORMAT_D32FS8: return GL_DEPTH32F_STENCIL8;
case sw::FORMAT_S8: return GL_STENCIL_INDEX8;
default:
UNREACHABLE(format);
}
return GL_DEPTH24_STENCIL8_OES;
}
} |
; intmax_t imaxabs(intmax_t j)
SECTION code_inttypes
PUBLIC _imaxabs
EXTERN _labs
defc _imaxabs = _labs
|
/*
* Copyright 2016-present Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <folly/fibers/Semaphore.h>
namespace folly {
namespace fibers {
bool Semaphore::signalSlow() {
// If we signalled a release, notify the waitlist
auto waitListLock = waitList_.wlock();
auto& waitList = *waitListLock;
auto testVal = tokens_.load(std::memory_order_acquire);
if (testVal != 0) {
return false;
}
if (waitList.empty()) {
// If the waitlist is now empty, ensure the token count increments
// No need for CAS here as we will always be under the mutex
CHECK(tokens_.compare_exchange_strong(
testVal, testVal + 1, std::memory_order_relaxed));
} else {
// trigger waiter if there is one
waitList.front()->post();
waitList.pop();
}
return true;
}
void Semaphore::signal() {
auto oldVal = tokens_.load(std::memory_order_acquire);
do {
if (oldVal == 0) {
if (signalSlow()) {
break;
}
}
} while (!tokens_.compare_exchange_weak(
oldVal,
oldVal + 1,
std::memory_order_release,
std::memory_order_acquire));
}
bool Semaphore::waitSlow() {
// Slow path, create a baton and acquire a mutex to update the wait list
folly::fibers::Baton waitBaton;
{
auto waitListLock = waitList_.wlock();
auto& waitList = *waitListLock;
auto testVal = tokens_.load(std::memory_order_acquire);
if (testVal != 0) {
return false;
}
// prepare baton and add to queue
waitList.push(&waitBaton);
}
// If we managed to create a baton, wait on it
// This has to be done here so the mutex has been released
waitBaton.wait();
return true;
}
void Semaphore::wait() {
auto oldVal = tokens_.load(std::memory_order_acquire);
do {
if (oldVal == 0) {
// If waitSlow fails it is because the token is non-zero by the time
// the lock is taken, so we can just continue round the loop
if (waitSlow()) {
break;
}
}
} while (!tokens_.compare_exchange_weak(
oldVal,
oldVal - 1,
std::memory_order_release,
std::memory_order_acquire));
}
size_t Semaphore::getCapacity() const {
return capacity_;
}
} // namespace fibers
} // namespace folly
|
.global s_prepare_buffers
s_prepare_buffers:
push %r10
push %r12
push %r15
push %r8
push %rbp
push %rbx
push %rcx
push %rdi
push %rsi
lea addresses_UC_ht+0x13a00, %rbx
nop
nop
nop
nop
nop
inc %rbp
movb (%rbx), %r15b
nop
nop
nop
nop
nop
inc %rsi
lea addresses_WT_ht+0x1ba80, %r8
nop
nop
dec %r10
mov (%r8), %r12d
inc %rbp
lea addresses_WC_ht+0x1d252, %rsi
lea addresses_UC_ht+0xdbf4, %rdi
nop
sub %r12, %r12
mov $98, %rcx
rep movsq
nop
nop
nop
inc %r8
lea addresses_UC_ht+0x9af5, %rdi
clflush (%rdi)
nop
nop
nop
nop
add $31889, %r10
movb $0x61, (%rdi)
nop
nop
nop
nop
add $23427, %rbp
lea addresses_WC_ht+0xc91a, %r12
nop
nop
nop
nop
sub $64044, %rbp
mov $0x6162636465666768, %rbx
movq %rbx, %xmm2
movups %xmm2, (%r12)
xor %r10, %r10
lea addresses_D_ht+0x1cf00, %r10
nop
dec %rbp
vmovups (%r10), %ymm2
vextracti128 $0, %ymm2, %xmm2
vpextrq $1, %xmm2, %rsi
and $44011, %r8
lea addresses_normal_ht+0x8680, %rsi
lea addresses_D_ht+0x51fc, %rdi
xor %rbx, %rbx
mov $59, %rcx
rep movsq
nop
nop
nop
nop
nop
dec %rbp
lea addresses_UC_ht+0x5530, %rsi
nop
nop
nop
add $13395, %rdi
mov (%rsi), %r12w
nop
nop
nop
nop
nop
and $38889, %rdi
lea addresses_D_ht+0x198c0, %rsi
lea addresses_D_ht+0xb340, %rdi
nop
cmp %r10, %r10
mov $1, %rcx
rep movsl
nop
nop
dec %rbx
lea addresses_A_ht+0x8d08, %rdi
nop
nop
add %rsi, %rsi
movups (%rdi), %xmm5
vpextrq $0, %xmm5, %r10
sub %rbx, %rbx
lea addresses_WC_ht+0x19a30, %rsi
lea addresses_WT_ht+0x11b00, %rdi
nop
nop
add %rbx, %rbx
mov $10, %rcx
rep movsb
nop
nop
nop
add $18296, %r10
lea addresses_UC_ht+0x1c300, %r15
dec %rsi
movb $0x61, (%r15)
nop
nop
nop
nop
dec %rcx
pop %rsi
pop %rdi
pop %rcx
pop %rbx
pop %rbp
pop %r8
pop %r15
pop %r12
pop %r10
ret
.global s_faulty_load
s_faulty_load:
push %r10
push %r13
push %r15
push %r8
push %rax
push %rbp
push %rsi
// Store
lea addresses_D+0x7e00, %rax
nop
nop
nop
nop
cmp %rbp, %rbp
mov $0x5152535455565758, %r10
movq %r10, %xmm2
movups %xmm2, (%rax)
nop
nop
nop
nop
nop
cmp %r8, %r8
// Faulty Load
lea addresses_WT+0x5a00, %rbp
clflush (%rbp)
nop
nop
dec %r13
mov (%rbp), %r15
lea oracles, %r13
and $0xff, %r15
shlq $12, %r15
mov (%r13,%r15,1), %r15
pop %rsi
pop %rbp
pop %rax
pop %r8
pop %r15
pop %r13
pop %r10
ret
/*
<gen_faulty_load>
[REF]
{'OP': 'LOAD', 'src': {'size': 4, 'NT': False, 'type': 'addresses_WT', 'same': False, 'AVXalign': False, 'congruent': 0}}
{'OP': 'STOR', 'dst': {'size': 16, 'NT': False, 'type': 'addresses_D', 'same': False, 'AVXalign': False, 'congruent': 10}}
[Faulty Load]
{'OP': 'LOAD', 'src': {'size': 8, 'NT': False, 'type': 'addresses_WT', 'same': True, 'AVXalign': False, 'congruent': 0}}
<gen_prepare_buffer>
{'OP': 'LOAD', 'src': {'size': 1, 'NT': False, 'type': 'addresses_UC_ht', 'same': False, 'AVXalign': False, 'congruent': 11}}
{'OP': 'LOAD', 'src': {'size': 4, 'NT': False, 'type': 'addresses_WT_ht', 'same': False, 'AVXalign': False, 'congruent': 4}}
{'OP': 'REPM', 'src': {'same': False, 'type': 'addresses_WC_ht', 'congruent': 0}, 'dst': {'same': False, 'type': 'addresses_UC_ht', 'congruent': 2}}
{'OP': 'STOR', 'dst': {'size': 1, 'NT': False, 'type': 'addresses_UC_ht', 'same': False, 'AVXalign': False, 'congruent': 0}}
{'OP': 'STOR', 'dst': {'size': 16, 'NT': False, 'type': 'addresses_WC_ht', 'same': False, 'AVXalign': False, 'congruent': 1}}
{'OP': 'LOAD', 'src': {'size': 32, 'NT': False, 'type': 'addresses_D_ht', 'same': False, 'AVXalign': False, 'congruent': 6}}
{'OP': 'REPM', 'src': {'same': False, 'type': 'addresses_normal_ht', 'congruent': 7}, 'dst': {'same': False, 'type': 'addresses_D_ht', 'congruent': 1}}
{'OP': 'LOAD', 'src': {'size': 2, 'NT': False, 'type': 'addresses_UC_ht', 'same': False, 'AVXalign': False, 'congruent': 4}}
{'OP': 'REPM', 'src': {'same': False, 'type': 'addresses_D_ht', 'congruent': 6}, 'dst': {'same': False, 'type': 'addresses_D_ht', 'congruent': 4}}
{'OP': 'LOAD', 'src': {'size': 16, 'NT': False, 'type': 'addresses_A_ht', 'same': False, 'AVXalign': False, 'congruent': 1}}
{'OP': 'REPM', 'src': {'same': True, 'type': 'addresses_WC_ht', 'congruent': 4}, 'dst': {'same': False, 'type': 'addresses_WT_ht', 'congruent': 8}}
{'OP': 'STOR', 'dst': {'size': 1, 'NT': False, 'type': 'addresses_UC_ht', 'same': False, 'AVXalign': False, 'congruent': 8}}
{'00': 21829}
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
*/
|
; A171129: a(n)=(n^4-n^3-n^2-n)/2.
; 0,-1,1,21,86,235,519,1001,1756,2871,4445,6589,9426,13091,17731,23505,30584,39151,49401,61541,75790,92379,111551,133561,158676,187175,219349,255501,295946,341011,391035,446369,507376,574431,647921,728245,815814
mov $3,$0
bin $3,2
mov $2,$3
sub $2,1
mov $1,$2
mov $4,$0
mul $4,$0
mul $4,$2
add $1,$4
mul $1,2
add $1,2
div $1,2
|
; Don't even think of reading this code
; It was automatically generated by md5-586.pl
; Which is a perl program used to generate the x86 assember for
; any of elf, a.out, BSDI, Win32, gaswin (for GNU as on Win32) or Solaris
; eric <eay@cryptsoft.com>
;
segment .text
global _md5_block_asm_host_order
_md5_block_asm_host_order:
push esi
push edi
mov edi, [12+esp]
mov esi, [16+esp]
mov ecx, [20+esp]
push ebp
shl ecx, 6
push ebx
add ecx, esi
sub ecx, 64
mov eax, [edi]
push ecx
mov ebx, [4+edi]
mov ecx, [8+edi]
mov edx, [12+edi]
L000start:
;
; R0 section
mov edi, ecx
mov ebp, [esi]
; R0 0
xor edi, edx
and edi, ebx
lea eax, [3614090360+ebp*1+eax]
xor edi, edx
add eax, edi
mov edi, ebx
rol eax, 7
mov ebp, [4+esi]
add eax, ebx
; R0 1
xor edi, ecx
and edi, eax
lea edx, [3905402710+ebp*1+edx]
xor edi, ecx
add edx, edi
mov edi, eax
rol edx, 12
mov ebp, [8+esi]
add edx, eax
; R0 2
xor edi, ebx
and edi, edx
lea ecx, [606105819+ebp*1+ecx]
xor edi, ebx
add ecx, edi
mov edi, edx
rol ecx, 17
mov ebp, [12+esi]
add ecx, edx
; R0 3
xor edi, eax
and edi, ecx
lea ebx, [3250441966+ebp*1+ebx]
xor edi, eax
add ebx, edi
mov edi, ecx
rol ebx, 22
mov ebp, [16+esi]
add ebx, ecx
; R0 4
xor edi, edx
and edi, ebx
lea eax, [4118548399+ebp*1+eax]
xor edi, edx
add eax, edi
mov edi, ebx
rol eax, 7
mov ebp, [20+esi]
add eax, ebx
; R0 5
xor edi, ecx
and edi, eax
lea edx, [1200080426+ebp*1+edx]
xor edi, ecx
add edx, edi
mov edi, eax
rol edx, 12
mov ebp, [24+esi]
add edx, eax
; R0 6
xor edi, ebx
and edi, edx
lea ecx, [2821735955+ebp*1+ecx]
xor edi, ebx
add ecx, edi
mov edi, edx
rol ecx, 17
mov ebp, [28+esi]
add ecx, edx
; R0 7
xor edi, eax
and edi, ecx
lea ebx, [4249261313+ebp*1+ebx]
xor edi, eax
add ebx, edi
mov edi, ecx
rol ebx, 22
mov ebp, [32+esi]
add ebx, ecx
; R0 8
xor edi, edx
and edi, ebx
lea eax, [1770035416+ebp*1+eax]
xor edi, edx
add eax, edi
mov edi, ebx
rol eax, 7
mov ebp, [36+esi]
add eax, ebx
; R0 9
xor edi, ecx
and edi, eax
lea edx, [2336552879+ebp*1+edx]
xor edi, ecx
add edx, edi
mov edi, eax
rol edx, 12
mov ebp, [40+esi]
add edx, eax
; R0 10
xor edi, ebx
and edi, edx
lea ecx, [4294925233+ebp*1+ecx]
xor edi, ebx
add ecx, edi
mov edi, edx
rol ecx, 17
mov ebp, [44+esi]
add ecx, edx
; R0 11
xor edi, eax
and edi, ecx
lea ebx, [2304563134+ebp*1+ebx]
xor edi, eax
add ebx, edi
mov edi, ecx
rol ebx, 22
mov ebp, [48+esi]
add ebx, ecx
; R0 12
xor edi, edx
and edi, ebx
lea eax, [1804603682+ebp*1+eax]
xor edi, edx
add eax, edi
mov edi, ebx
rol eax, 7
mov ebp, [52+esi]
add eax, ebx
; R0 13
xor edi, ecx
and edi, eax
lea edx, [4254626195+ebp*1+edx]
xor edi, ecx
add edx, edi
mov edi, eax
rol edx, 12
mov ebp, [56+esi]
add edx, eax
; R0 14
xor edi, ebx
and edi, edx
lea ecx, [2792965006+ebp*1+ecx]
xor edi, ebx
add ecx, edi
mov edi, edx
rol ecx, 17
mov ebp, [60+esi]
add ecx, edx
; R0 15
xor edi, eax
and edi, ecx
lea ebx, [1236535329+ebp*1+ebx]
xor edi, eax
add ebx, edi
mov edi, ecx
rol ebx, 22
mov ebp, [4+esi]
add ebx, ecx
;
; R1 section
; R1 16
lea eax, [4129170786+ebp*1+eax]
xor edi, ebx
and edi, edx
mov ebp, [24+esi]
xor edi, ecx
add eax, edi
mov edi, ebx
rol eax, 5
add eax, ebx
; R1 17
lea edx, [3225465664+ebp*1+edx]
xor edi, eax
and edi, ecx
mov ebp, [44+esi]
xor edi, ebx
add edx, edi
mov edi, eax
rol edx, 9
add edx, eax
; R1 18
lea ecx, [643717713+ebp*1+ecx]
xor edi, edx
and edi, ebx
mov ebp, [esi]
xor edi, eax
add ecx, edi
mov edi, edx
rol ecx, 14
add ecx, edx
; R1 19
lea ebx, [3921069994+ebp*1+ebx]
xor edi, ecx
and edi, eax
mov ebp, [20+esi]
xor edi, edx
add ebx, edi
mov edi, ecx
rol ebx, 20
add ebx, ecx
; R1 20
lea eax, [3593408605+ebp*1+eax]
xor edi, ebx
and edi, edx
mov ebp, [40+esi]
xor edi, ecx
add eax, edi
mov edi, ebx
rol eax, 5
add eax, ebx
; R1 21
lea edx, [38016083+ebp*1+edx]
xor edi, eax
and edi, ecx
mov ebp, [60+esi]
xor edi, ebx
add edx, edi
mov edi, eax
rol edx, 9
add edx, eax
; R1 22
lea ecx, [3634488961+ebp*1+ecx]
xor edi, edx
and edi, ebx
mov ebp, [16+esi]
xor edi, eax
add ecx, edi
mov edi, edx
rol ecx, 14
add ecx, edx
; R1 23
lea ebx, [3889429448+ebp*1+ebx]
xor edi, ecx
and edi, eax
mov ebp, [36+esi]
xor edi, edx
add ebx, edi
mov edi, ecx
rol ebx, 20
add ebx, ecx
; R1 24
lea eax, [568446438+ebp*1+eax]
xor edi, ebx
and edi, edx
mov ebp, [56+esi]
xor edi, ecx
add eax, edi
mov edi, ebx
rol eax, 5
add eax, ebx
; R1 25
lea edx, [3275163606+ebp*1+edx]
xor edi, eax
and edi, ecx
mov ebp, [12+esi]
xor edi, ebx
add edx, edi
mov edi, eax
rol edx, 9
add edx, eax
; R1 26
lea ecx, [4107603335+ebp*1+ecx]
xor edi, edx
and edi, ebx
mov ebp, [32+esi]
xor edi, eax
add ecx, edi
mov edi, edx
rol ecx, 14
add ecx, edx
; R1 27
lea ebx, [1163531501+ebp*1+ebx]
xor edi, ecx
and edi, eax
mov ebp, [52+esi]
xor edi, edx
add ebx, edi
mov edi, ecx
rol ebx, 20
add ebx, ecx
; R1 28
lea eax, [2850285829+ebp*1+eax]
xor edi, ebx
and edi, edx
mov ebp, [8+esi]
xor edi, ecx
add eax, edi
mov edi, ebx
rol eax, 5
add eax, ebx
; R1 29
lea edx, [4243563512+ebp*1+edx]
xor edi, eax
and edi, ecx
mov ebp, [28+esi]
xor edi, ebx
add edx, edi
mov edi, eax
rol edx, 9
add edx, eax
; R1 30
lea ecx, [1735328473+ebp*1+ecx]
xor edi, edx
and edi, ebx
mov ebp, [48+esi]
xor edi, eax
add ecx, edi
mov edi, edx
rol ecx, 14
add ecx, edx
; R1 31
lea ebx, [2368359562+ebp*1+ebx]
xor edi, ecx
and edi, eax
mov ebp, [20+esi]
xor edi, edx
add ebx, edi
mov edi, ecx
rol ebx, 20
add ebx, ecx
;
; R2 section
; R2 32
xor edi, edx
xor edi, ebx
lea eax, [4294588738+ebp*1+eax]
add eax, edi
rol eax, 4
mov ebp, [32+esi]
mov edi, ebx
; R2 33
lea edx, [2272392833+ebp*1+edx]
add eax, ebx
xor edi, ecx
xor edi, eax
mov ebp, [44+esi]
add edx, edi
mov edi, eax
rol edx, 11
add edx, eax
; R2 34
xor edi, ebx
xor edi, edx
lea ecx, [1839030562+ebp*1+ecx]
add ecx, edi
rol ecx, 16
mov ebp, [56+esi]
mov edi, edx
; R2 35
lea ebx, [4259657740+ebp*1+ebx]
add ecx, edx
xor edi, eax
xor edi, ecx
mov ebp, [4+esi]
add ebx, edi
mov edi, ecx
rol ebx, 23
add ebx, ecx
; R2 36
xor edi, edx
xor edi, ebx
lea eax, [2763975236+ebp*1+eax]
add eax, edi
rol eax, 4
mov ebp, [16+esi]
mov edi, ebx
; R2 37
lea edx, [1272893353+ebp*1+edx]
add eax, ebx
xor edi, ecx
xor edi, eax
mov ebp, [28+esi]
add edx, edi
mov edi, eax
rol edx, 11
add edx, eax
; R2 38
xor edi, ebx
xor edi, edx
lea ecx, [4139469664+ebp*1+ecx]
add ecx, edi
rol ecx, 16
mov ebp, [40+esi]
mov edi, edx
; R2 39
lea ebx, [3200236656+ebp*1+ebx]
add ecx, edx
xor edi, eax
xor edi, ecx
mov ebp, [52+esi]
add ebx, edi
mov edi, ecx
rol ebx, 23
add ebx, ecx
; R2 40
xor edi, edx
xor edi, ebx
lea eax, [681279174+ebp*1+eax]
add eax, edi
rol eax, 4
mov ebp, [esi]
mov edi, ebx
; R2 41
lea edx, [3936430074+ebp*1+edx]
add eax, ebx
xor edi, ecx
xor edi, eax
mov ebp, [12+esi]
add edx, edi
mov edi, eax
rol edx, 11
add edx, eax
; R2 42
xor edi, ebx
xor edi, edx
lea ecx, [3572445317+ebp*1+ecx]
add ecx, edi
rol ecx, 16
mov ebp, [24+esi]
mov edi, edx
; R2 43
lea ebx, [76029189+ebp*1+ebx]
add ecx, edx
xor edi, eax
xor edi, ecx
mov ebp, [36+esi]
add ebx, edi
mov edi, ecx
rol ebx, 23
add ebx, ecx
; R2 44
xor edi, edx
xor edi, ebx
lea eax, [3654602809+ebp*1+eax]
add eax, edi
rol eax, 4
mov ebp, [48+esi]
mov edi, ebx
; R2 45
lea edx, [3873151461+ebp*1+edx]
add eax, ebx
xor edi, ecx
xor edi, eax
mov ebp, [60+esi]
add edx, edi
mov edi, eax
rol edx, 11
add edx, eax
; R2 46
xor edi, ebx
xor edi, edx
lea ecx, [530742520+ebp*1+ecx]
add ecx, edi
rol ecx, 16
mov ebp, [8+esi]
mov edi, edx
; R2 47
lea ebx, [3299628645+ebp*1+ebx]
add ecx, edx
xor edi, eax
xor edi, ecx
mov ebp, [esi]
add ebx, edi
mov edi, -1
rol ebx, 23
add ebx, ecx
;
; R3 section
; R3 48
xor edi, edx
or edi, ebx
lea eax, [4096336452+ebp*1+eax]
xor edi, ecx
mov ebp, [28+esi]
add eax, edi
mov edi, -1
rol eax, 6
xor edi, ecx
add eax, ebx
; R3 49
or edi, eax
lea edx, [1126891415+ebp*1+edx]
xor edi, ebx
mov ebp, [56+esi]
add edx, edi
mov edi, -1
rol edx, 10
xor edi, ebx
add edx, eax
; R3 50
or edi, edx
lea ecx, [2878612391+ebp*1+ecx]
xor edi, eax
mov ebp, [20+esi]
add ecx, edi
mov edi, -1
rol ecx, 15
xor edi, eax
add ecx, edx
; R3 51
or edi, ecx
lea ebx, [4237533241+ebp*1+ebx]
xor edi, edx
mov ebp, [48+esi]
add ebx, edi
mov edi, -1
rol ebx, 21
xor edi, edx
add ebx, ecx
; R3 52
or edi, ebx
lea eax, [1700485571+ebp*1+eax]
xor edi, ecx
mov ebp, [12+esi]
add eax, edi
mov edi, -1
rol eax, 6
xor edi, ecx
add eax, ebx
; R3 53
or edi, eax
lea edx, [2399980690+ebp*1+edx]
xor edi, ebx
mov ebp, [40+esi]
add edx, edi
mov edi, -1
rol edx, 10
xor edi, ebx
add edx, eax
; R3 54
or edi, edx
lea ecx, [4293915773+ebp*1+ecx]
xor edi, eax
mov ebp, [4+esi]
add ecx, edi
mov edi, -1
rol ecx, 15
xor edi, eax
add ecx, edx
; R3 55
or edi, ecx
lea ebx, [2240044497+ebp*1+ebx]
xor edi, edx
mov ebp, [32+esi]
add ebx, edi
mov edi, -1
rol ebx, 21
xor edi, edx
add ebx, ecx
; R3 56
or edi, ebx
lea eax, [1873313359+ebp*1+eax]
xor edi, ecx
mov ebp, [60+esi]
add eax, edi
mov edi, -1
rol eax, 6
xor edi, ecx
add eax, ebx
; R3 57
or edi, eax
lea edx, [4264355552+ebp*1+edx]
xor edi, ebx
mov ebp, [24+esi]
add edx, edi
mov edi, -1
rol edx, 10
xor edi, ebx
add edx, eax
; R3 58
or edi, edx
lea ecx, [2734768916+ebp*1+ecx]
xor edi, eax
mov ebp, [52+esi]
add ecx, edi
mov edi, -1
rol ecx, 15
xor edi, eax
add ecx, edx
; R3 59
or edi, ecx
lea ebx, [1309151649+ebp*1+ebx]
xor edi, edx
mov ebp, [16+esi]
add ebx, edi
mov edi, -1
rol ebx, 21
xor edi, edx
add ebx, ecx
; R3 60
or edi, ebx
lea eax, [4149444226+ebp*1+eax]
xor edi, ecx
mov ebp, [44+esi]
add eax, edi
mov edi, -1
rol eax, 6
xor edi, ecx
add eax, ebx
; R3 61
or edi, eax
lea edx, [3174756917+ebp*1+edx]
xor edi, ebx
mov ebp, [8+esi]
add edx, edi
mov edi, -1
rol edx, 10
xor edi, ebx
add edx, eax
; R3 62
or edi, edx
lea ecx, [718787259+ebp*1+ecx]
xor edi, eax
mov ebp, [36+esi]
add ecx, edi
mov edi, -1
rol ecx, 15
xor edi, eax
add ecx, edx
; R3 63
or edi, ecx
lea ebx, [3951481745+ebp*1+ebx]
xor edi, edx
mov ebp, [24+esp]
add ebx, edi
add esi, 64
rol ebx, 21
mov edi, [ebp]
add ebx, ecx
add eax, edi
mov edi, [4+ebp]
add ebx, edi
mov edi, [8+ebp]
add ecx, edi
mov edi, [12+ebp]
add edx, edi
mov [ebp], eax
mov [4+ebp], ebx
mov edi, [esp]
mov [8+ebp], ecx
mov [12+ebp], edx
cmp edi, esi
jge NEAR L000start
pop eax
pop ebx
pop ebp
pop edi
pop esi
ret
|
/* TEMPLATE GENERATED TESTCASE FILE
Filename: CWE124_Buffer_Underwrite__malloc_wchar_t_cpy_62a.cpp
Label Definition File: CWE124_Buffer_Underwrite__malloc.label.xml
Template File: sources-sink-62a.tmpl.cpp
*/
/*
* @description
* CWE: 124 Buffer Underwrite
* BadSource: Set data pointer to before the allocated memory buffer
* GoodSource: Set data pointer to the allocated memory buffer
* Sinks: cpy
* BadSink : Copy string to data using wcscpy
* Flow Variant: 62 Data flow: data flows using a C++ reference from one function to another in different source files
*
* */
#include "std_testcase.h"
#include <wchar.h>
namespace CWE124_Buffer_Underwrite__malloc_wchar_t_cpy_62
{
#ifndef OMITBAD
/* bad function declaration */
void badSource(wchar_t * &data);
void bad()
{
wchar_t * data;
data = NULL;
badSource(data);
{
wchar_t source[100];
wmemset(source, L'C', 100-1); /* fill with 'C's */
source[100-1] = L'\0'; /* null terminate */
/* POTENTIAL FLAW: Possibly copying data to memory before the destination buffer */
wcscpy(data, source);
printWLine(data);
/* INCIDENTAL CWE-401: Memory Leak - data may not point to location
* returned by malloc() so can't safely call free() on it */
}
}
#endif /* OMITBAD */
#ifndef OMITGOOD
/* goodG2B uses the GoodSource with the BadSink */
void goodG2BSource(wchar_t * &data);
static void goodG2B()
{
wchar_t * data;
data = NULL;
goodG2BSource(data);
{
wchar_t source[100];
wmemset(source, L'C', 100-1); /* fill with 'C's */
source[100-1] = L'\0'; /* null terminate */
/* POTENTIAL FLAW: Possibly copying data to memory before the destination buffer */
wcscpy(data, source);
printWLine(data);
/* INCIDENTAL CWE-401: Memory Leak - data may not point to location
* returned by malloc() so can't safely call free() on it */
}
}
void good()
{
goodG2B();
}
#endif /* OMITGOOD */
} /* close namespace */
/* Below is the main(). It is only used when building this testcase on
* its own for testing or for building a binary to use in testing binary
* analysis tools. It is not used when compiling all the testcases as one
* application, which is how source code analysis tools are tested.
*/
#ifdef INCLUDEMAIN
using namespace CWE124_Buffer_Underwrite__malloc_wchar_t_cpy_62; /* so that we can use good and bad easily */
int main(int argc, char * argv[])
{
/* seed randomness */
srand( (unsigned)time(NULL) );
#ifndef OMITGOOD
printLine("Calling good()...");
good();
printLine("Finished good()");
#endif /* OMITGOOD */
#ifndef OMITBAD
printLine("Calling bad()...");
bad();
printLine("Finished bad()");
#endif /* OMITBAD */
return 0;
}
#endif
|
;**************************************************
;* ----- Protracker V2.3B Playroutine ----- *
;**************************************************
;
; Version 6.1
; Written by Frank Wille in 2013, 2016, 2017, 2018, 2019, 2020.
;
; I, the copyright holder of this work, hereby release it into the
; public domain. This applies worldwide.
;
; 6.1 minimal (unofficial) - Antiriad's mods for small executable size
; - Removed SDATA code.
; - mt_data is in BSS (no longer completely PC relative, focused on exe size)
; - Period and finetune table generated in code saving about 1KB.
; - Vibrato sine table generate in code saving about 1KB.
; - VUMeter trigger added in _mt_VUMeter which allows for demo/music sync effects with playing notes
;
; The default version (single section, local base register) should
; work with most assemblers. Tested are: Devpac, vasm, PhxAss,
; Barfly-Asm, SNMA, AsmOne, AsmPro.
;
; Exported functions and variables:
; (CUSTOM is the custom-chip register set base address $dff000.)
;
; _mt_install_cia(a6=CUSTOM, a0=VectorBase, d0=PALflag.b)
; Install a CIA-B interrupt for calling _mt_music or mt_sfxonly.
; The music module is replayed via _mt_music when _mt_Enable is non-zero.
; Otherwise the interrupt handler calls mt_sfxonly to play sound
; effects only. VectorBase is 0 for 68000, otherwise set it to the CPU's
; VBR register. A non-zero PALflag selects PAL-clock for the CIA timers
; (NTSC otherwise).
;
; _mt_remove_cia(a6=CUSTOM)
; Remove the CIA-B music interrupt, restore the previous handler and
; reset the CIA timer registers to their original values.
;
; _mt_init(a6=CUSTOM, a0=TrackerModule, a1=Samples|NULL, d0=InitialSongPos.b)
; Initialize a new module.
; Reset speed to 6, tempo to 125 and start at the given song position.
; Master volume is at 64 (maximum).
; When a1 is NULL the samples are assumed to be stored after the patterns.
;
; _mt_end(a6=CUSTOM)
; Stop playing current module and sound effects.
;
; _mt_soundfx(a6=CUSTOM, a0=SamplePointer,
; d0=SampleLength.w, d1=SamplePeriod.w, d2=SampleVolume.w)
; Request playing of an external sound effect on the most unused channel.
; This function is for compatibility with the old API only.
; You should call _mt_playfx instead. !MINIMAL only.
;
; channelStatus = _mt_playfx(a6=CUSTOM, a0=SfxStructurePointer)
; Request playing of a prioritized external sound effect, either on a
; fixed channel or on the most unused one.
; Structure layout of SfxStructure:
; void *sfx_ptr (pointer to sample start in Chip RAM, even address)
; WORD sfx_len (sample length in words)
; WORD sfx_per (hardware replay period for sample)
; WORD sfx_vol (volume 0..64, is unaffected by the song's master volume)
; BYTE sfx_cha (0..3 selected replay channel, -1 selects best channel)
; BYTE sfx_pri (priority, must be in the range 1..127)
; When multiple samples are assigned to the same channel the lower
; priority sample will be replaced. When priorities are the same, then
; the older sample is replaced.
; The chosen channel is blocked for music until the effect has
; completely been replayed.
; Returns a pointer to a channel-status structure when the sample
; is scheduled for playing, and NULL when the request was ignored.
; !MINIMAL only.
;
; _mt_loopfx(a6=CUSTOM, a0=SfxStructurePointer)
; Request playing of a looped sound effect on a fixed channel, which
; will be blocked for music until the effect is stopped (_mt_stopfx).
; It uses the same sfx-structure as _mt_playfx, but the priority is
; ignored. A looped sound effect has always highest priority and will
; replace a previous effect on the same channel. No automatic channel
; selection possible!
; Also make sure the sample starts with a zero-word, which is used
; for idling when the effect is stopped. This word is included in the
; total length calculation, but excluded when actually playing the loop.
; !MINIMAL only.
;
; _mt_stopfx(a6=CUSTOM, d0=Channel.b)
; Immediately stop a currently playing sound effect on a channel (0..3)
; and make it available for music, or other effects, again. This is the
; only way to stop a looped sound effect (_mt_loopfx), besides stopping
; replay completely (_mt_end). !MINIMAL only.
;
; _mt_musicmask(a6=CUSTOM, d0=ChannelMask.b)
; Bits set in the mask define which specific channels are reserved
; for music only. Set bit 0 for channel 0, ..., bit 3 for channel 3.
; When calling _mt_soundfx or _mt_playfx with automatic channel selection
; (sfx_cha=-1) then these masked channels will never be picked.
; The mask defaults to 0. !MINIMAL only.
;
; _mt_mastervol(a6=CUSTOM, d0=MasterVolume.w)
; Set a master volume from 0 to 64 for all music channels.
; Note that the master volume does not affect the volume of external
; sound effects (which is desired). !MINIMAL only.
;
; _mt_samplevol(d0=SampleNumber.w, d1=Volume.b)
; Redefine a sample's volume. May also be done while the song is playing.
; Warning: Does not check arguments for valid range! You must have done
; _mt_init before calling this function!
; The new volume is persistent. Even when the song is restarted.
; !MINIMAL only.
;
; _mt_music(a6=CUSTOM)
; The replayer routine. Is called automatically after _mt_install_cia.
;
; Byte Variables:
;
; _mt_Enable
; Set this byte to non-zero to play music, zero to pause playing.
; Note that you can still play sound effects, while music is stopped.
; It is set to 0 by _mt_install_cia.
;
; _mt_E8Trigger
; This byte reflects the value of the last E8 command.
; It is reset to 0 after _mt_init.
;
; _mt_MusicChannels
; This byte defines the number of channels which should be dedicated
; for playing music. So sound effects will never use more
; than 4 - _mt_MusicChannels channels at once. Defaults to 0.
; !MINIMAL only.
;
; Optionally you can build a minimal version, which includes just
; the player. No sound effects insert, no master volume, no sample
; volume, etc. Define the symbol MINIMAL=1 for it.
ifnd MINIMAL
MINIMAL equ 1
endc
; You may disable sawtooth and rectangle vibratos/tremolos here, which
; will be replaced by sine-waves. They are rarely used and disabling
; them will free a lot of memory for the tables.
ifnd ENABLE_SAWRECT
ENABLE_SAWRECT equ 0
endc
; Set this if you can guarantee that the word at $0 is cleared and if
; you want to use if for idle-looping of samples.
ifnd NULL_IS_CLEARED
NULL_IS_CLEARED equ 0
endc
;Antiriad: Added vumeter polling for syncing demos
ifnd ENABLE_VUMETER
ENABLE_VUMETER equ 0
endc
; Delay in CIA-ticks, which guarantees that at least one Audio-DMA
; took place, even with the lowest periods.
; 496 should be the correct value. But there are some A1200 which
; need at least 550.
DMADELAY equ 576 ; was 496
; Custom chip registers - try and catch predefined EQUs - if it fails sort this
; out yourself :)
ifnd CUSTOM
CUSTOM equ $dff000
endc ;CUSTOM
ifnd INTREQR
INTREQR equ $01e
INTENAR equ $01c
DMACON equ $096
INTENA equ $09a
INTREQ equ $09c
endc ;INTREQR
ifnd AUD0LC
AUD0LC equ $0a0
AUD0LEN equ $0a4
AUD0VOL equ $0a8
AUD1LC equ $0b0
AUD1LEN equ $0b4
AUD1VOL equ $0b8
AUD2LC equ $0c0
AUD2LEN equ $0c4
AUD2VOL equ $0c8
AUD3LC equ $0d0
AUD3LEN equ $0d4
AUD3VOL equ $0d8
endc ;AUD0LC
; Audio channel registers
ifnd AUDLC
AUDLC equ 0
AUDLEN equ 4
AUDPER equ 6
AUDVOL equ 8
endc ;AUDLC
; CIA registers
ifnd CIAA
CIAA equ $bfe001
CIAB equ $bfd000
endc ;CIAA
ifnd CIATALO
CIAPRA equ $000
CIATALO equ $400
CIATAHI equ $500
CIATBLO equ $600
CIATBHI equ $700
CIAICR equ $d00
CIACRA equ $e00
CIACRB equ $f00
endc ;CIATALO
; Sound effects structure, passed into _mt_playfx
rsreset
sfx_ptr rs.l 1
sfx_len rs.w 1
sfx_per rs.w 1
sfx_vol rs.w 1
sfx_cha rs.b 1
sfx_pri rs.b 1
sfx_sizeof rs.b 0
; Channel Status
rsreset
n_note rs.w 1
n_cmd rs.b 1
n_cmdlo rs.b 1
n_index rs.b 1
n_sfxpri rs.b 1
n_reserved1 rs.b 2
n_start rs.l 1
n_loopstart rs.l 1
n_length rs.w 1
n_replen rs.w 1
n_period rs.w 1
n_volume rs.w 1
n_pertab rs.l 1
n_dmabit rs.w 1
n_noteoff rs.w 1
n_toneportspeed rs.w 1
n_wantedperiod rs.w 1
n_pattpos rs.w 1
n_funk rs.w 1
n_wavestart rs.l 1
n_reallength rs.w 1
n_intbit rs.w 1
n_sfxptr rs.l 1
n_sfxlen rs.w 1
n_sfxper rs.w 1
n_sfxvol rs.w 1
n_looped rs.b 1
n_minusft rs.b 1
n_vibratoamp rs.b 1
n_vibratospd rs.b 1
n_vibratopos rs.b 1
n_vibratoctrl rs.b 1
n_tremoloamp rs.b 1
n_tremolospd rs.b 1
n_tremolopos rs.b 1
n_tremoloctrl rs.b 1
n_gliss rs.b 1
n_sampleoffset rs.b 1
n_loopcount rs.b 1
n_funkoffset rs.b 1
n_retrigcount rs.b 1
ifeq MINIMAL
n_freecnt rs.b 1
n_musiconly rs.b 1
n_reserved2 rs.b 1
else
n_reserved2 rs.b 3
endc
n_sizeof rs.b 0
;---------------------------------------------------------------------------
xdef _mt_install_cia
_mt_install_cia:
; Install a CIA-B interrupt for calling _mt_music.
; a6 = CUSTOM
; a0 = VectorBase
; d0 = PALflag.b (0 is NTSC)
move.l a4,-(sp)
lea mt_data,a4
clr.b mt_Enable(a4)
; remember level 6 vector and interrupt enable
lea $78(a0),a0
move.l a0,mt_Lev6Int(a4)
move.w #$2000,d1
and.w INTENAR(a6),d1
or.w #$8000,d1
move.w d1,mt_Lev6Ena(a4)
; disable level 6 EXTER interrupts, set player interrupt vector
move.w #$2000,INTENA(a6)
move.l (a0),mt_oldLev6(a4)
lea mt_TimerAInt(pc),a1
move.l a1,(a0)
; reset TimerB toggle
lea TB_toggle(pc),a0
clr.b (a0)
; disable CIA-B interrupts, stop and save all timers
lea CIAB,a0
moveq #0,d1
move.b #$7f,CIAICR(a0)
move.b d1,CIACRA(a0)
move.b d1,CIACRB(a0)
lea mt_oldtimers(a4),a1
move.b CIATALO(a0),(a1)+
move.b CIATAHI(a0),(a1)+
move.b CIATBLO(a0),(a1)+
move.b CIATBHI(a0),(a1)
; determine if 02 clock for timers is based on PAL or NTSC
tst.b d0
bne .1
move.l #1789773,d0 ; NTSC
bra .2
.1: move.l #1773447,d0 ; PAL
.2: move.l d0,mt_timerval(a4)
; load TimerA in continuous mode for the default tempo of 125
divu #125,d0
move.b d0,CIATALO(a0)
lsr.w #8,d0
move.b d0,CIATAHI(a0)
move.b #$11,CIACRA(a0) ; load timer, start continuous
; load TimerB with DMADELAY ticks for setting DMA and repeat
move.b #DMADELAY&255,CIATBLO(a0)
move.b #DMADELAY>>8,CIATBHI(a0)
; Ack. pending interrupts, TimerA and TimerB interrupt enable
tst.b CIAICR(a0)
move.w #$2000,INTREQ(a6)
move.b #$83,CIAICR(a0)
; enable level 6 interrupts
move.w #$a000,INTENA(a6)
bra mt_reset
;---------------------------------------------------------------------------
xdef _mt_remove_cia
_mt_remove_cia:
; Remove CIA-B music interrupt and restore the old vector.
; a6 = CUSTOM
move.l a4,-(sp)
lea mt_data,a4
; disable level 6 and CIA-B interrupts
lea CIAB,a0
move.w #$2000,d0
move.b #$7f,CIAICR(a0)
move.w d0,INTENA(a6)
tst.b CIAICR(a0)
move.w d0,INTREQ(a6)
; restore old timer values
lea mt_oldtimers(a4),a1
move.b (a1)+,CIATALO(a0)
move.b (a1)+,CIATAHI(a0)
move.b (a1)+,CIATBLO(a0)
move.b (a1),CIATBHI(a0)
move.b #$10,CIACRA(a0)
move.b #$10,CIACRB(a0)
; restore original level 6 interrupt vector
move.l mt_Lev6Int(a4),a1
move.l mt_oldLev6(a4),(a1)
; reenable CIA-B ALRM interrupt, which was set by AmigaOS
move.b #$84,CIAICR(a0)
; reenable previous level 6 interrupt
move.w mt_Lev6Ena(a4),INTENA(a6)
move.l (sp)+,a4
rts
;---------------------------------------------------------------------------
mt_TimerAInt:
; TimerA interrupt calls _mt_music at a selectable tempo (Fxx command),
; which defaults to 50 times per second.
; check for TB interrupt and clear CIAB interrupt flags
btst #1,CIAB+CIAICR
bne mt_TimerBInt
; Now it should be a TA interrupt.
; Other level 6 interrupt sources have to be handled elsewhere.
movem.l d0-d7/a0-a6,-(sp)
lea CUSTOM,a6
lea mt_data,a4
; clear EXTER interrupt flag
move.w #$2000,INTREQ(a6)
; do music when enabled
tst.b mt_Enable(a4)
ifeq MINIMAL
beq .2
else
beq .1
endc
bsr _mt_music ; music with sfx inserted
.1: movem.l (sp)+,d0-d7/a0-a6
nop
rte
ifeq MINIMAL
.2: bsr mt_sfxonly ; no music, only sfx
movem.l (sp)+,d0-d7/a0-a6
nop
rte
endc
;---------------------------------------------------------------------------
mt_TimerBInt:
; Handle one-shot TimerB interrupt.
; TB_toggle-technique suggested by Ross/EAB.
move.l a0,-(sp)
lea TB_toggle(pc),a0
not.b (a0)
lea CUSTOM+INTREQ,a0
beq mt_TimerBsetrep
; restart timer for repeat, enable audio DMA after DMADELAY ticks
move.w #$2000,(a0) ; clear EXTER interrupt flag
move.b #$19,CIAB+CIACRB
move.w mt_dmaon(pc),DMACON-INTREQ(a0)
move.l (sp)+,a0
nop
rte
mt_dmaon:
dc.w $8000
TB_toggle:
dc.b 0
even
;---------------------------------------------------------------------------
mt_TimerBsetrep:
; Oneshot TimerB interrupt to set repeat samples after another DMADELAY ticks.
; a0 = INTREQ
; clear EXTER and possible audio interrupt flags
move.l a4,-(sp)
move.l d0,a4
moveq #$2000>>7,d0 ; EXTER-flag
or.b mt_dmaon+1(pc),d0
lsl.w #7,d0
move.w d0,(a0)
move.l a4,d0
; set repeat sample pointers and lengths
lea mt_data,a4
move.l mt_chan1+n_loopstart(a4),AUD0LC-INTREQ(a0)
move.w mt_chan1+n_replen(a4),AUD0LEN-INTREQ(a0)
move.l mt_chan2+n_loopstart(a4),AUD1LC-INTREQ(a0)
move.w mt_chan2+n_replen(a4),AUD1LEN-INTREQ(a0)
move.l mt_chan3+n_loopstart(a4),AUD2LC-INTREQ(a0)
move.w mt_chan3+n_replen(a4),AUD2LEN-INTREQ(a0)
move.l mt_chan4+n_loopstart(a4),AUD3LC-INTREQ(a0)
move.w mt_chan4+n_replen(a4),AUD3LEN-INTREQ(a0)
move.l (sp)+,a4
move.l (sp)+,a0
nop
rte
;---------------------------------------------------------------------------
; Antiriad:
; Generates an accurate period/finetune table in ~140 bytes
; In: a4, mt_data
;
; See: https://eab.abime.net/showpost.php?p=1416034&postcount=47
mt_generate_period_table:
movem.l d2-d5,-(sp)
lea mt_PeriodTable(a4),a0
lea .seeds(pc),a1
moveq #0,d3
moveq #16-1,d5 ;16 tuning tables
.tloop:
move.w (a1)+,d0 ;get 'patched' semitone-up period *64
move.l (a1)+,d2 ;get correction bitmap
moveq #36-1,d4 ;36 words per table
.loop1:
mulu #$F1A8,d0 ;~1/(2^(1/12))*65536 - 0.16 fixed point
swap.w d0 ;/65536
move.w d0,d1
lsr.w #6,d1 ;/64
add.l d2,d2
subx.w d3,d1
move.w d1,(a0)+
dbf d4,.loop1
dbf d5,.tloop
; Create the finetune lookup table. This is a word offset like so:
;mt_PerFineTune: (16 words)
; dc.w mt_Tuning0-mt_PerFineTune,mt_Tuning1-mt_PerFineTune
; dc.w mt_Tuning2-mt_PerFineTune,mt_Tuning3-mt_PerFineTune
; dc.w mt_Tuning4-mt_PerFineTune,mt_Tuning5-mt_PerFineTune
; dc.w mt_Tuning6-mt_PerFineTune,mt_Tuning7-mt_PerFineTune
; dc.w mt_TuningM8-mt_PerFineTune,mt_TuningM7-mt_PerFineTune
; dc.w mt_TuningM6-mt_PerFineTune,mt_TuningM5-mt_PerFineTune
; dc.w mt_TuningM4-mt_PerFineTune,mt_TuningM3-mt_PerFineTune
; dc.w mt_TuningM2-mt_PerFineTune,mt_TuningM1-mt_PerFineTune
;mt_PeriodTable:
;mt_Tuning0:
;mt_PerfFineTune is 16 words, each tuning table is 36 words
lea mt_PerFineTune(a4),a0
moveq #16*2,d0 ;First offset is just the size of mt_PerfFineTune
moveq #16-1,d1 ;16 tables
moveq #36*2,d2 ;table size
.floop:
move.w d0,(a0)+
add.w d2,d0
dbf d1,.floop
movem.l (sp)+,d2-d5
rts
.seeds:
dc.w $E2B4,$0FC0,$F920 ;mt_Tuning0
dc.w $E159,$69D5,$E000 ;mt_Tuning1
dc.w $DF8C,$0000,$0000 ;mt_Tuning2
dc.w $DE31,$3B67,$A080 ;mt_Tuning3
dc.w $DC64,$0006,$0000 ;mt_Tuning4
dc.w $DAC2,$0000,$0400 ;mt_Tuning5
dc.w $D977,$F5F2,$C840 ;mt_Tuning6
dc.w $D7AF,$1200,$0000 ;mt_Tuning7
dc.w $F036,$07E0,$7C90 ;mt_TuningM8
dc.w $EE85,$0200,$1120 ;mt_TuningM7
dc.w $ECCC,$0000,$0000 ;mt_TuningM6
dc.w $EB62,$9DB3,$D040 ;mt_TuningM5
dc.w $E96E,$0023,$0000 ;mt_TuningM4
dc.w $E7BF,$0000,$0200 ;mt_TuningM3
dc.w $E632,$9868,$4000 ;mt_TuningM2
dc.w $E461,$0000,$0000 ;mt_TuningM1
;---------------------------------------------------------------------------
; Antiriad:
; Generates the sine vibrato table. Thanks to a/b.
; In: a4, mt_data
;
; See: https://eab.abime.net/showpost.php?p=1465997&postcount=132
mt_generate_vib_sine_table:
move.l d2,-(sp)
lea (mt_VibratoSineTable_End-64)(a4),a1
moveq #15*2,d2
.VTLoop1
lea (.table,pc),a0
moveq #64/2-1,d1
.VTLoop2
move.w (a0)+,d0
mulu.w d2,d0
swap d0
move.b d0,(a1)+
neg.b d0
move.b d0,(32-1,a1)
dbf d1,.VTLoop2
lea (-64/2-64,a1),a1
subq.w #1*2,d2
bge.b .VTLoop1
move.l (sp)+,d2
rts
.table
dc.w $0000,$1800,$3100,$4a00,$6100,$7800,$8d00,$a100
dc.w $b400,$c500,$d400,$e000,$eb00,$f400,$fa00,$fd00
dc.w $ff00,$fd00,$fa00,$f400,$eb00,$e000,$d400,$c500
dc.w $b400,$a100,$8d00,$7800,$6100,$4a00,$3100,$1800
;---------------------------------------------------------------------------
xdef _mt_init
_mt_init:
; Initialize new module.
; Reset speed to 6, tempo to 125 and start at given song position.
; Master volume is at 64 (maximum).
; a6 = CUSTOM
; a0 = module pointer
; a1 = sample pointer (NULL means samples are stored within the module)
; d0 = initial song position
move.l a4,-(sp)
lea mt_data,a4
move.l a0,mt_mod(a4)
movem.l d2/a2,-(sp)
; set initial song position
cmp.b 950(a0),d0
blo .1
moveq #0,d0
.1: move.b d0,mt_SongPos(a4)
move.l a1,d0 ; sample data location is given?
bne .4
; get number of highest pattern
lea 952(a0),a1 ; song arrangement list
moveq #127,d0
moveq #0,d2
.2: move.b (a1)+,d1
cmp.b d2,d1
bls .3
move.b d1,d2
.3: dbf d0,.2
addq.b #1,d2 ; number of patterns
; now we can calculate the base address of the sample data
moveq #10,d0
asl.l d0,d2
lea (a0,d2.l),a1
;add.w #1084,a1
lea 1084(a1),a1 ;Antiriad
; save start address of each sample and do some fixes for broken mods
.4: lea mt_SampleStarts(a4),a2
moveq #1,d2
moveq #31-1,d0
.5: move.l a1,(a2)+
moveq #0,d1
move.w 42(a0),d1
cmp.w d2,d1 ; length 0 and 1 define unused samples
bls .6
add.l d1,d1
add.l d1,a1
bra .7
.6: clr.w 42(a0) ; length 1 means zero -> no sample
.7: lea 30(a0),a0
dbf d0,.5
movem.l (sp)+,d2/a2
; reset CIA timer A to default (125)
move.l mt_timerval(a4),d0
divu #125,d0
move.b d0,CIAB+CIATALO
lsr.w #8,d0
move.b d0,CIAB+CIATAHI
;Antiriad - generator code
bsr mt_generate_period_table ;Create period table
bsr mt_generate_vib_sine_table ;Create sine vibrato table
;Antiriad - end
;Fallthrough to mt_reset
mt_reset:
; a4 must be initialised with base register
; reset speed and counters
move.b #6,mt_Speed(a4)
clr.b mt_Counter(a4)
clr.w mt_PatternPos(a4)
; disable the filter
or.b #2,CIAA+CIAPRA
ifeq MINIMAL
; set master volume to 64
lea MasterVolTab64(pc),a0
move.l a0,mt_MasterVolTab(a4)
endc
; set channel index
clr.b mt_chan1+n_index(a4)
move.b #1,mt_chan2+n_index(a4)
move.b #2,mt_chan3+n_index(a4)
move.b #3,mt_chan4+n_index(a4)
; initialise channel DMA and interrupt bits
move.w #$0001,mt_chan1+n_dmabit(a4)
move.w #$0002,mt_chan2+n_dmabit(a4)
move.w #$0004,mt_chan3+n_dmabit(a4)
move.w #$0008,mt_chan4+n_dmabit(a4)
move.w #$0080,mt_chan1+n_intbit(a4)
move.w #$0100,mt_chan2+n_intbit(a4)
move.w #$0200,mt_chan3+n_intbit(a4)
move.w #$0400,mt_chan4+n_intbit(a4)
; make sure n_period doesn't start as 0
move.w #320,d0
move.w d0,mt_chan1+n_period(a4)
move.w d0,mt_chan2+n_period(a4)
move.w d0,mt_chan3+n_period(a4)
move.w d0,mt_chan4+n_period(a4)
; disable sound effects
clr.w mt_chan1+n_sfxlen(a4)
clr.w mt_chan2+n_sfxlen(a4)
clr.w mt_chan3+n_sfxlen(a4)
clr.w mt_chan4+n_sfxlen(a4)
clr.b mt_E8Trigger(a4)
ifeq MINIMAL
clr.b mt_SongEnd(a4)
clr.b mt_SilCntValid(a4)
endc
move.l (sp)+,a4
;---------------------------------------------------------------------------
xdef _mt_end
_mt_end:
; Stop playing current module.
; a6 = CUSTOM
lea mt_data,a0
clr.b mt_Enable(a0)
clr.w mt_chan1+n_volume(a0)
clr.w mt_chan2+n_volume(a0)
clr.w mt_chan3+n_volume(a0)
clr.w mt_chan4+n_volume(a0)
moveq #0,d0
move.w d0,AUD0VOL(a6)
move.w d0,AUD1VOL(a6)
move.w d0,AUD2VOL(a6)
move.w d0,AUD3VOL(a6)
move.w #$000f,DMACON(a6)
rts
ifeq MINIMAL
;---------------------------------------------------------------------------
xdef _mt_soundfx
_mt_soundfx:
; Request playing of an external sound effect on the most unused channel.
; This function is for compatibility with the old API only!
; You should call _mt_playfx instead!
; a6 = CUSTOM
; a0 = sample pointer
; d0.w = sample length in words
; d1.w = sample period
; d2.w = sample volume
lea -sfx_sizeof(sp),sp
move.l a0,sfx_ptr(sp)
movem.w d0-d2,sfx_len(sp)
move.w #$ff01,sfx_cha(sp) ; any channel, priority=1
move.l sp,a0
bsr _mt_playfx
lea sfx_sizeof(sp),sp
rts
;---------------------------------------------------------------------------
xdef _mt_playfx
_mt_playfx:
; Request playing of a prioritized external sound effect, either on a
; fixed channel or on the most unused one.
; A negative channel specification means to use the best one.
; The priority is unsigned and should be greater than zero.
; This channel will be blocked for music until the effect has finished.
; a6 = CUSTOM
; a0 = sfx-structure pointer with the following layout:
; 0: ptr, 4: len.w, 6: period.w, 8: vol.w, 10: channel.b, 11: priority.b
; -> d0 = pointer to channel status or NULL when sample was ignored
movem.l d2-d7/a0-a5,-(sp)
lea mt_data,a4
move.w #$4000,INTENA(a6)
moveq #0,d0
move.b sfx_cha(a0),d0
bpl channelsfx ; use fixed channel for effect
; Did we already calculate the n_freecnt values for all channels?
tst.b mt_SilCntValid(a4)
bne freecnt_valid
; Look at the next 8 pattern steps to find the longest sequence
; of silence (no new note or instrument).
moveq #8,d2
move.l #$fffff000,d3 ; mask to ignore effects
; reset freecnts for all channels
moveq #0,d0
move.b d0,mt_chan1+n_freecnt(a4)
move.b d0,mt_chan2+n_freecnt(a4)
move.b d0,mt_chan3+n_freecnt(a4)
move.b d0,mt_chan4+n_freecnt(a4)
moveq #-1,d4
moveq #-1,d5
moveq #-1,d6
moveq #-1,d7
; get pattern pointer
move.l mt_mod(a4),a3 ; a3 mod pointer
lea 952(a3),a5 ; a5 song arrangement list
move.w mt_PatternPos(a4),d1
move.b mt_SongPos(a4),d0
.1: move.b (a5,d0.w),d0
swap d0
lea 1084(a3),a1
lsr.l #6,d0
add.l d0,a1
lea 1024(a1),a2 ; a2 end of pattern
add.w d1,a1 ; a1 current pattern pos
.2: moveq #0,d0
move.l (a1)+,d1
and.l d3,d1
sne d1
and.b d1,d4
sub.b d4,mt_chan1+n_freecnt(a4)
add.b d4,d0
move.l (a1)+,d1
and.l d3,d1
sne d1
and.b d1,d5
sub.b d5,mt_chan2+n_freecnt(a4)
add.b d5,d0
move.l (a1)+,d1
and.l d3,d1
sne d1
and.b d1,d6
sub.b d6,mt_chan3+n_freecnt(a4)
add.b d6,d0
move.l (a1)+,d1
and.l d3,d1
sne d1
and.b d1,d7
sub.b d7,mt_chan4+n_freecnt(a4)
add.b d7,d0
; break the loop when no channel has any more free pattern steps
beq .7
; otherwise break after 8 pattern steps
subq.w #1,d2
beq .7
; End of pattern reached? Then load next pattern pointer.
cmp.l a2,a1
blo .2
moveq #0,d1
moveq #1,d0
add.b mt_SongPos(a4),d0
and.w #$007f,d0
cmp.b 950(a3),d0 ; end of song reached?
blo .1
moveq #0,d0
bra .1
.7: st mt_SilCntValid(a4)
freecnt_valid:
sub.l a2,a2
move.b sfx_pri(a0),d2
; Determine which channels are already allocated for sound
; effects and check if the limit was reached. In this case only
; replace sound effect channels by higher priority.
moveq #3,d0
sub.b mt_MusicChannels(a4),d0
move.b mt_chan1+n_sfxpri(a4),d4
or.b mt_chan1+n_musiconly(a4),d4
sne d1
add.b d1,d0
move.b mt_chan2+n_sfxpri(a4),d5
or.b mt_chan2+n_musiconly(a4),d5
sne d1
add.b d1,d0
move.b mt_chan3+n_sfxpri(a4),d6
or.b mt_chan3+n_musiconly(a4),d6
sne d1
add.b d1,d0
move.b mt_chan4+n_sfxpri(a4),d7
or.b mt_chan4+n_musiconly(a4),d7
sne d1
add.b d1,d0
bmi .overwrite ; all channels reserved/playing effects
; We will prefer a music channel which had an audio interrupt,
; because that means the last instrument sample has been played
; completely, and the channel is now in an idle loop.
; Also exclude channels which have set a repeat loop.
; Try not to break them!
moveq #0,d3
tst.b mt_chan1+n_looped(a4)
bne .1
or.w #$0080,d3
.1: tst.b mt_chan2+n_looped(a4)
bne .2
or.w #$0100,d3
.2: tst.b mt_chan3+n_looped(a4)
bne .3
or.w #$0200,d3
.3: tst.b mt_chan4+n_looped(a4)
bne .4
or.w #$0400,d3
.4: move.w INTREQR(a6),d1
and.w d3,d1
bne .6
; All channels are busy. Then break the non-looped ones first...
move.w d3,d1
bne .6
; ..except there are none. Then it doesn't matter. :|
move.w #$0780,d1
; first look for the best unused channel
.6: moveq #0,d3
btst #7,d1
seq d0
or.b d4,d0
bne .7
lea mt_chan1+n_freecnt(a4),a1
cmp.b (a1),d3
bhi .7
move.l a1,a2
move.b (a1),d3
.7: btst #8,d1
seq d0
or.b d5,d0
bne .8
lea mt_chan2+n_freecnt(a4),a1
cmp.b (a1),d3
bhi .8
move.l a1,a2
move.b (a1),d3
.8: btst #9,d1
seq d0
or.b d6,d0
bne .9
lea mt_chan3+n_freecnt(a4),a1
cmp.b (a1),d3
bhi .9
move.l a1,a2
move.b (a1),d3
.9: btst #10,d1
seq d0
or.b d7,d0
bne .10
lea mt_chan4+n_freecnt(a4),a1
cmp.b (a1),d3
bhi .10
move.l a1,a2
bra found_sfx_ch
.10: move.l a2,d3
bne found_sfx_ch
.overwrite:
; finally try to overwrite a sound effect with lower/equal priority
moveq #0,d3
tst.b d4
beq .11
cmp.b d4,d2
blo .11
lea mt_chan1+n_freecnt(a4),a1
cmp.b (a1),d3
bhi .11
move.l a1,a2
move.b (a1),d3
.11: tst.b d5
beq .12
cmp.b d5,d2
blo .12
lea mt_chan2+n_freecnt(a4),a1
cmp.b (a1),d3
bhi .12
move.l a1,a2
move.b (a1),d3
.12: tst.b d6
beq .13
cmp.b d6,d2
blo .13
lea mt_chan3+n_freecnt(a4),a1
cmp.b (a1),d3
bhi .13
move.l a1,a2
move.b (a1),d3
.13: tst.b d7
beq .14
cmp.b d7,d2
blo .14
lea mt_chan4+n_freecnt(a4),a1
cmp.b (a1),d3
bhi .14
move.l a1,a2
.14: move.l a2,d3
beq exit_playfx ; ignore new sfx due to low priority
found_sfx_ch:
lea -n_freecnt(a2),a2
bra set_sfx
channelsfx:
; a0 = sfx structure
; d0 = fixed channel for new sound effect
add.w d0,d0
lea mt_chan1(a4),a2
add.w channel_offsets(pc,d0.w),a2
; priority high enough to replace a present effect on this channel?
move.b sfx_pri(a0),d2
cmp.b n_sfxpri(a2),d2
bhs set_sfx
sub.l a2,a2
bra exit_playfx
set_sfx:
; activate the sound effect on this channel
; a0 = sfx structure
; d2 = sfx priority
; a2 = channel status
move.l (a0)+,n_sfxptr(a2) ; sfx_ptr
move.w (a0)+,n_sfxlen(a2) ; sfx_len
move.w (a0)+,n_sfxper(a2) ; sfx_per
move.w (a0),n_sfxvol(a2) ; sfx_vol
move.b d2,n_sfxpri(a2)
exit_playfx:
move.w #$c000,INTENA(a6)
move.l a2,d0 ; ptr to selected channel or NULL
movem.l (sp)+,d2-d7/a0-a5
rts
channel_offsets:
dc.w 0*n_sizeof,1*n_sizeof,2*n_sizeof,3*n_sizeof
;---------------------------------------------------------------------------
xdef _mt_loopfx
_mt_loopfx:
; Request playing of a looped sound effect on a fixed channel, which
; will be blocked for music until the effect is stopped (_mt_stopfx).
; It uses the same sfx-structure as _mt_playfx, but the priority is
; ignored. A looped sound effect has always highest priority and will
; replace a previous effect on the same channel. No automatic channel
; selection possible!
; Also make sure the sample starts with a zero-word, which is used
; for idling when the effect is stopped. This word is included in the
; total length calculation, but excluded when actually playing the loop.
; a6 = CUSTOM
; a0 = sfx-structure pointer with the following layout:
; 0: ptr, 4: len.w, 6: period.w, 8: vol.w, 10: channel.b
lea mt_data+mt_chan1,a1
moveq #3,d0
and.b sfx_cha(a0),d0
add.w d0,d0
add.w channel_offsets(pc,d0.w),a1
move.w #$4000,INTENA(a6)
move.l (a0)+,n_sfxptr(a1) ; sfx_ptr
move.w (a0)+,n_sfxlen(a1) ; sfx_len
move.w (a0)+,n_sfxper(a1) ; sfx_per
move.w (a0),n_sfxvol(a1) ; sfx_vol
st n_sfxpri(a1) ; sfx_pri -1 enables looped mode
move.w #$c000,INTENA(a6)
rts
;---------------------------------------------------------------------------
xdef _mt_stopfx
_mt_stopfx:
; Immediately stop a currently playing sound effect on a channel.
; a6 = CUSTOM
; d0.b = channel (0..3)
lea mt_data+mt_chan1,a0
and.w #3,d0
add.w d0,d0
add.w channel_offsets(pc,d0.w),a0
move.w #$4000,INTENA(a6)
tst.b n_sfxpri(a0)
beq .1 ; no sfx playing anyway
moveq #1,d0
move.b d0,n_sfxpri(a0)
move.w d0,n_sfxlen(a0) ; idle loop
move.w #108,n_sfxper(a0) ; enter idle as quickly as possible
clr.w n_sfxvol(a0) ; and cut volume
ifne NULL_IS_CLEARED
clr.b n_looped(a0)
clr.l n_sfxptr(a0) ; use $0 for idle-looping
else
tst.b n_looped(a0)
beq .1
clr.b n_looped(a0)
subq.l #2,n_sfxptr(a0) ; idle loop at sample-start - 2
endc
.1: move.w #$c000,INTENA(a6)
rts
;---------------------------------------------------------------------------
xdef _mt_musicmask
_mt_musicmask:
; Set bits in the mask define which specific channels are reserved
; for music only.
; a6 = CUSTOM
; d0.b = channel-mask (bit 0 for channel 0, ..., bit 3 for channel 3)
move.l a4,-(sp)
lea mt_data,a4
move.w #$4000,INTENA(a6)
lsl.b #5,d0
scs mt_chan4+n_musiconly(a4)
add.b d0,d0
scs mt_chan3+n_musiconly(a4)
add.b d0,d0
scs mt_chan2+n_musiconly(a4)
add.b d0,d0
scs mt_chan1+n_musiconly(a4)
move.w #$c000,INTENA(a6)
move.l (sp)+,a4
rts
;---------------------------------------------------------------------------
xdef _mt_mastervol
_mt_mastervol:
; Set a master volume from 0 to 64 for all music channels.
; Note that the master volume does not affect the volume of external
; sound effects (which is desired).
; a6 = CUSTOM
; d0.w = master volume
move.l a4,-(sp)
lea mt_data,a4
; stingray, since each volume table has a size of 65 bytes
; we simply multiply (optimised of course) by 65 to get the
; offset to the correct table
lea MasterVolTab0(pc),a0
add.w d0,a0
lsl.w #6,d0
add.w d0,a0
move.w #$4000,INTENA(a6)
; adapt all channel volumes immediately
move.l a0,mt_MasterVolTab(a4)
move.w mt_chan1+n_volume(a4),d0
move.b (a0,d0.w),d0
move.w d0,AUD0VOL(a6)
move.w mt_chan2+n_volume(a4),d0
move.b (a0,d0.w),d0
move.w d0,AUD1VOL(a6)
move.w mt_chan3+n_volume(a4),d0
move.b (a0,d0.w),d0
move.w d0,AUD2VOL(a6)
move.w mt_chan4+n_volume(a4),d0
move.b (a0,d0.w),d0
move.w d0,AUD3VOL(a6)
move.w #$c000,INTENA(a6)
move.l (sp)+,a4
rts
;---------------------------------------------------------------------------
xdef _mt_samplevol
_mt_samplevol:
; Redefine a sample's volume. May also be done while the song is playing.
; Warning: Does not check arguments for valid range! You must have done
; _mt_init before calling this function!
; The new volume is persistent. Even when the song is restarted.
; d0.w = sample number (0-31)
; d1.b = volume (0-64)
move.l mt_data+mt_mod,a0
swap d1
move.w d0,d1
add.w d1,d1
lsl.w #5,d0
sub.w d1,d0 ; table index: sample number * 30
swap d1
move.b d1,12+3(a0,d0.w) ; set sample's volume
rts
endc ; !MINIMAL
;---------------------------------------------------------------------------
xdef _mt_music
_mt_music:
; Called from interrupt.
; Play next position when Counter equals Speed.
; Effects are always handled.
; a6 = CUSTOM
moveq #0,d7 ; d7 is always zero
lea mt_dmaon+1(pc),a0
move.b d7,(a0)
addq.b #1,mt_Counter(a4)
move.b mt_Counter(a4),d0
cmp.b mt_Speed(a4),d0
blo no_new_note
; handle a new note
move.b d7,mt_Counter(a4)
tst.b mt_PattDelTime2(a4)
beq get_new_note
; we have a pattern delay, check effects then step
lea AUD0LC(a6),a5
lea mt_chan1(a4),a2
bsr mt_checkfx
lea AUD1LC(a6),a5
lea mt_chan2(a4),a2
bsr mt_checkfx
lea AUD2LC(a6),a5
lea mt_chan3(a4),a2
bsr mt_checkfx
lea AUD3LC(a6),a5
lea mt_chan4(a4),a2
bsr mt_checkfx
bra settb_step
no_new_note:
; no new note, just check effects, don't step to next position
lea AUD0LC(a6),a5
lea mt_chan1(a4),a2
bsr mt_checkfx
lea AUD1LC(a6),a5
lea mt_chan2(a4),a2
bsr mt_checkfx
lea AUD2LC(a6),a5
lea mt_chan3(a4),a2
bsr mt_checkfx
lea AUD3LC(a6),a5
lea mt_chan4(a4),a2
bsr mt_checkfx
; set one-shot TimerB interrupt for enabling DMA, when needed
move.b mt_dmaon+1(pc),d0
beq same_pattern
move.b #$19,CIAB+CIACRB ; load/start timer B, one-shot
bra same_pattern
get_new_note:
; determine pointer to current pattern line
move.l mt_mod(a4),a0
lea 12(a0),a3 ; sample info table
lea 1084(a0),a1 ; pattern data
lea 952(a0),a0
moveq #0,d0
move.b mt_SongPos(a4),d0
move.b (a0,d0.w),d0 ; current pattern number
swap d0
lsr.l #6,d0
add.l d0,a1 ; pattern base
add.w mt_PatternPos(a4),a1 ; a1 pattern line
; play new note for each channel, apply some effects
lea AUD0LC(a6),a5
lea mt_chan1(a4),a2
bsr mt_playvoice
lea AUD1LC(a6),a5
lea mt_chan2(a4),a2
bsr mt_playvoice
lea AUD2LC(a6),a5
lea mt_chan3(a4),a2
bsr mt_playvoice
lea AUD3LC(a6),a5
lea mt_chan4(a4),a2
bsr mt_playvoice
;Antiriad: Check which channels are playing new notes and set bitmask in _mt_VUMeter
;chan1 = 1, chan2 = 2, chan3 = 4, chan4 = 8
;Note up to the caller to clear _mt_VUMeter when reading.
ifne ENABLE_VUMETER
moveq #0,d0
.vu1:
tst.w mt_chan1(a4)
beq.s .vu2
addq.b #1,d0
.vu2:
tst.w mt_chan2(a4)
beq.s .vu3
addq.b #2,d0
.vu3:
tst.w mt_chan3(a4)
beq.s .vu4
addq.b #4,d0
.vu4:
tst.w mt_chan4(a4)
beq.s .vuwrite
addq.b #8,d0
.vuwrite:
or.b d0,mt_VUMeter(a4) ;merge final flag
endc ;ENABLE_VUMETER
settb_step:
; set one-shot TimerB interrupt for enabling DMA, when needed
move.b mt_dmaon+1(pc),d0
beq pattern_step
move.b #$19,CIAB+CIACRB ; load/start timer B, one-shot
pattern_step:
; next pattern line, handle delay and break
ifeq MINIMAL
clr.b mt_SilCntValid(a4) ; recalculate silence counters
endc
moveq #16,d2 ; offset to next pattern line
move.b mt_PattDelTime2(a4),d1
move.b mt_PattDelTime(a4),d0
beq .1
move.b d0,d1
move.b d7,mt_PattDelTime(a4)
.1: tst.b d1
beq .3
subq.b #1,d1
beq .2
moveq #0,d2 ; do not advance to next line
.2: move.b d1,mt_PattDelTime2(a4)
.3: add.w mt_PatternPos(a4),d2 ; d2 PatternPos
; check for break
bclr d7,mt_PBreakFlag(a4)
beq .4
move.w mt_PBreakPos(a4),d2
move.w d7,mt_PBreakPos(a4)
; check whether end of pattern is reached
.4: move.w d2,mt_PatternPos(a4)
cmp.w #1024,d2
blo same_pattern
song_step:
move.w mt_PBreakPos(a4),mt_PatternPos(a4)
move.w d7,mt_PBreakPos(a4)
move.b d7,mt_PosJumpFlag(a4)
; next position in song
moveq #1,d0
add.b mt_SongPos(a4),d0
and.w #$007f,d0
move.l mt_mod(a4),a0
cmp.b 950(a0),d0 ; end of song reached?
blo .1
moveq #0,d0 ; restart the song from the beginning
ifeq MINIMAL
addq.b #1,mt_SongEnd(a4)
bne .2
clr.b mt_Enable(a4) ; stop the song when mt_SongEnd was -1
.2: and.b #$7f,mt_SongEnd(a4)
endc
.1: move.b d0,mt_SongPos(a4)
same_pattern:
tst.b mt_PosJumpFlag(a4)
bne song_step
rts
ifeq MINIMAL
;---------------------------------------------------------------------------
mt_sfxonly:
; Called from interrupt.
; Plays sound effects on free channels.
; a6 = CUSTOM
moveq #0,d7 ; d7 is always zero
lea mt_dmaon+1(pc),a0
move.b d7,(a0)
lea AUD0LC(a6),a5
lea mt_chan1(a4),a2
bsr chan_sfx_only
lea AUD1LC(a6),a5
lea mt_chan2(a4),a2
bsr chan_sfx_only
lea AUD2LC(a6),a5
lea mt_chan3(a4),a2
bsr chan_sfx_only
lea AUD3LC(a6),a5
lea mt_chan4(a4),a2
bsr chan_sfx_only
move.b mt_dmaon+1(pc),d0
beq .1
move.b #$19,CIAB+CIACRB ; load/start timer B, one-shot
.1: rts
chan_sfx_only:
; Check for new sound samples. Check if previous ones are finished.
; a2 = channel data
; a5 = audio registers
tst.b n_sfxpri(a2)
beq .1
move.w n_sfxlen(a2),d0
bne start_sfx
tst.b n_looped(a2)
bne .1
move.w n_intbit(a2),d0
and.w INTREQR(a6),d0
beq .1
move.w n_dmabit(a2),d0
and.w mt_dmaon(pc),d0
bne .1
; last sound effect sample has played, so unblock this channel again
move.b d7,n_sfxpri(a2)
.1: rts
;---------------------------------------------------------------------------
start_sfx:
; d0 = sfx_len in words
; a2 = channel data
; a5 = audio registers
; play new sound effect on this channel
move.w n_dmabit(a2),d1
move.w d1,DMACON(a6)
move.l n_sfxptr(a2),a0
tst.b n_sfxpri(a2)
bpl .1
; looped sound effect
st n_looped(a2)
addq.l #2,a0 ; skip first word, used for idling
subq.w #1,d0
move.l a0,AUDLC(a5)
move.w d0,AUDLEN(a5)
bra .2
; normal sound effect
.1: move.b d7,n_looped(a2)
move.l a0,AUDLC(a5)
move.w d0,AUDLEN(a5)
moveq #1,d0 ; idles after playing once
ifne NULL_IS_CLEARED
sub.l a0,a0
endc
; save repeat and period for TimerB interrupt
.2: move.l a0,n_loopstart(a2)
move.w d0,n_replen(a2)
move.w n_sfxper(a2),d0
move.w d0,AUDPER(a5)
move.w d0,n_period(a2)
move.w n_sfxvol(a2),AUDVOL(a5)
move.w d7,n_sfxlen(a2) ; don't call start_sfx again
lea mt_dmaon(pc),a0
or.w d1,(a0) ; DMA-channel to enable on TimerB
rts
endc ; !MINIMAL
;---------------------------------------------------------------------------
mt_checkfx:
; a2 = channel data
; a5 = audio registers
ifeq MINIMAL
tst.b n_sfxpri(a2)
beq .3
move.w n_sfxlen(a2),d0
beq .2
bsr start_sfx
; channel is blocked, only check some E-commands
.1: move.w #$0fff,d4
and.w n_cmd(a2),d4
move.w d4,d0
clr.b d0
cmp.w #$0e00,d0
bne mt_nop
and.w #$00ff,d4
bra blocked_e_cmds
.2: tst.b n_looped(a2)
bne .1
move.w n_intbit(a2),d0
and.w INTREQR(a6),d0
beq .1
move.w n_dmabit(a2),d0
and.w mt_dmaon(pc),d0
bne .1
; sound effect sample has played, so unblock this channel again
move.b d7,n_sfxpri(a2)
endc ; !MINIMAL
; do channel effects between notes
.3: move.w n_funk(a2),d0
beq .4
bsr mt_updatefunk
.4: move.w #$0fff,d4
and.w n_cmd(a2),d4
beq mt_pernop
and.w #$00ff,d4
moveq #$0f,d0
and.b n_cmd(a2),d0
add.w d0,d0
move.w fx_tab(pc,d0.w),d0
jmp fx_tab(pc,d0.w)
fx_tab:
dc.w mt_arpeggio-fx_tab ; $0
dc.w mt_portaup-fx_tab
dc.w mt_portadown-fx_tab
dc.w mt_toneporta-fx_tab
dc.w mt_vibrato-fx_tab ; $4
dc.w mt_tonevolslide-fx_tab
dc.w mt_vibrvolslide-fx_tab
dc.w mt_tremolo-fx_tab
dc.w mt_nop-fx_tab ; $8
dc.w mt_nop-fx_tab
dc.w mt_volumeslide-fx_tab
dc.w mt_nop-fx_tab
dc.w mt_nop-fx_tab ; $C
dc.w mt_nop-fx_tab
dc.w mt_e_cmds-fx_tab
dc.w mt_nop-fx_tab
mt_pernop:
; just set the current period
move.w n_period(a2),AUDPER(a5)
mt_nop:
rts
;---------------------------------------------------------------------------
mt_playvoice:
; a1 = pattern ptr
; a2 = channel data
; a3 = sample info table
; a5 = audio registers
move.l (a1)+,d6 ; d6 current note/cmd words
ifeq MINIMAL
; channel blocked by external sound effect?
tst.b n_sfxpri(a2)
beq .2
move.w n_sfxlen(a2),d0
beq .1
bsr start_sfx
bra moreblockedfx
; do only some limited commands, while sound effect is in progress
.1: tst.b n_looped(a2)
bne moreblockedfx
move.w n_intbit(a2),d0
and.w INTREQR(a6),d0
beq moreblockedfx
move.w n_dmabit(a2),d0
and.w mt_dmaon(pc),d0
bne moreblockedfx
; sound effect sample has played, so unblock this channel again
move.b d7,n_sfxpri(a2)
endc ; !MINIMAL
.2: tst.l (a2) ; n_note/cmd: any note or cmd set?
bne .3
move.w n_period(a2),AUDPER(a5)
.3: move.l d6,(a2)
moveq #15,d5
and.b n_cmd(a2),d5
add.w d5,d5 ; d5 cmd*2
moveq #0,d4
move.b d6,d4 ; d4 cmd argument (in MSW)
swap d4
move.w #$0ff0,d4
and.w d6,d4 ; d4 for checking E-cmd (in LSW)
swap d6
move.l d6,d0 ; S...S...
clr.b d0
rol.w #4,d0
rol.l #4,d0 ; ....00SS
and.w #$0fff,d6 ; d6 note
; get sample start address
add.w d0,d0 ; sample number * 2
beq set_regs
move.w mult30tab(pc,d0.w),d1 ; d1 sample info table offset
lea mt_SampleStarts(a4),a0
add.w d0,d0
move.l -4(a0,d0.w),d2
; read length, volume and repeat from sample info table
lea (a3,d1.w),a0
move.w (a0)+,d0 ; length
bne .4
ifne NULL_IS_CLEARED
moveq #0,d2 ; use $0 for empty samples
else
; use the first two bytes from the first sample for empty samples
move.l mt_SampleStarts(a4),d2
endc
addq.w #1,d0
.4: move.l d2,n_start(a2)
move.w d0,n_reallength(a2)
; determine period table from fine-tune parameter
moveq #0,d3
move.b (a0)+,d3
add.w d3,d3
move.l a0,d1
lea mt_PerFineTune(a4),a0 ;Antiriad: Finetune table is generated and in mt_data section
add.w (a0,d3.w),a0
move.l a0,n_pertab(a2)
move.l d1,a0
cmp.w #2*8,d3
shs n_minusft(a2)
moveq #0,d1
move.b (a0)+,d1 ; volume
move.w d1,n_volume(a2)
move.w (a0)+,d3 ; repeat offset
beq no_offset
; set repeat
add.l d3,d2
add.l d3,d2
move.w (a0),d0
move.w d0,n_replen(a2)
exg d0,d3 ; n_replen to d3
add.w d3,d0
bra set_len_start
mult30tab:
dc.w 0*30,1*30,2*30,3*30,4*30,5*30,6*30,7*30
dc.w 8*30,9*30,10*30,11*30,12*30,13*30,14*30,15*30
dc.w 16*30,17*30,18*30,19*30,20*30,21*30,22*30,23*30
dc.w 24*30,25*30,26*30,27*30,28*30,29*30,30*30,31*30
no_offset:
move.w (a0),d3
ifne NULL_IS_CLEARED
cmp.w #1,d3
beq .1
bhi set_replen
else
bne set_replen
endc
; repeat length zero means idle-looping
addq.w #1,d3
.1: moveq #0,d2 ; expect two zero bytes at $0
set_replen:
move.w d3,n_replen(a2)
set_len_start:
move.w d0,n_length(a2)
move.l d2,n_loopstart(a2)
move.l d2,n_wavestart(a2)
ifeq MINIMAL
move.l mt_MasterVolTab(a4),a0
move.b (a0,d1.w),d1
endc
move.w d1,AUDVOL(a5)
; remember if sample is looped
; @@@ FIXME: also need to check if n_loopstart equals n_start
subq.w #1,d3
sne n_looped(a2)
set_regs:
; d4 = cmd argument | masked E-cmd
; d5 = cmd*2
; d6 = cmd.w | note.w
move.w d4,d3 ; d3 masked E-cmd
swap d4 ; d4 cmd argument into LSW
tst.w d6
beq checkmorefx ; no new note
cmp.w #$0e50,d3
beq set_finetune
move.w prefx_tab(pc,d5.w),d0
jmp prefx_tab(pc,d0.w)
prefx_tab:
dc.w set_period-prefx_tab,set_period-prefx_tab,set_period-prefx_tab
dc.w set_toneporta-prefx_tab ; $3
dc.w set_period-prefx_tab
dc.w set_toneporta-prefx_tab ; $5
dc.w set_period-prefx_tab,set_period-prefx_tab,set_period-prefx_tab
dc.w set_sampleoffset-prefx_tab ; $9
dc.w set_period-prefx_tab,set_period-prefx_tab,set_period-prefx_tab
dc.w set_period-prefx_tab,set_period-prefx_tab,set_period-prefx_tab
set_toneporta:
move.l n_pertab(a2),a0 ; tuned period table
; find first period which is less or equal the note in d6
moveq #36-1,d0
moveq #-2,d1
.1: addq.w #2,d1
cmp.w (a0)+,d6
dbhs d0,.1
tst.b n_minusft(a2) ; negative fine tune?
beq .2
tst.w d1
beq .2
subq.l #2,a0 ; then take previous period
subq.w #2,d1
.2: move.w d1,n_noteoff(a2) ; note offset in period table
move.w n_period(a2),d2
move.w -(a0),d1
cmp.w d1,d2
bne .3
moveq #0,d1
.3: move.w d1,n_wantedperiod(a2)
move.w n_funk(a2),d0
beq .4
bsr mt_updatefunk
.4: move.w d2,AUDPER(a5)
rts
set_sampleoffset:
; cmd 9 x y (xy = offset in 256 bytes)
; d4 = xy
moveq #0,d0
move.b d4,d0
bne .1
move.b n_sampleoffset(a2),d0
bra .2
.1: move.b d0,n_sampleoffset(a2)
.2: lsl.w #7,d0
cmp.w n_length(a2),d0
bhs .3
sub.w d0,n_length(a2)
add.w d0,d0
add.l d0,n_start(a2)
bra set_period
.3: move.w #1,n_length(a2)
bra set_period
set_finetune:
lea mt_PerFineTune(a4),a0 ;Antiriad: Finetune table is generated and in mt_data section
moveq #$0f,d0
and.b n_cmdlo(a2),d0
add.w d0,d0
add.w (a0,d0.w),a0
move.l a0,n_pertab(a2)
cmp.w #2*8,d0
shs n_minusft(a2)
set_period:
; find nearest period for a note value, then apply finetuning
; d3 = masked E-cmd
; d4 = cmd argument
; d5 = cmd*2
; d6 = note.w
lea mt_PeriodTable(a4),a0 ;Antiriad: Finetune table is generated and in mt_data section
moveq #36-1,d0
moveq #-2,d1
.1: addq.w #2,d1 ; table offset
cmp.w (a0)+,d6
dbhs d0,.1
; apply finetuning, set period and note-offset
move.l n_pertab(a2),a0
move.w (a0,d1.w),d2
move.w d2,n_period(a2)
move.w d1,n_noteoff(a2)
; check for notedelay
cmp.w #$0ed0,d3 ; notedelay
beq checkmorefx
; disable DMA
move.w n_dmabit(a2),d0
move.w d0,DMACON(a6)
btst #2,n_vibratoctrl(a2)
bne .2
move.b d7,n_vibratopos(a2)
.2: btst #2,n_tremoloctrl(a2)
bne .3
move.b d7,n_tremolopos(a2)
.3: move.l n_start(a2),AUDLC(a5)
move.w n_length(a2),AUDLEN(a5)
move.w d2,AUDPER(a5)
lea mt_dmaon(pc),a0
or.w d0,(a0)
checkmorefx:
; d4 = cmd argument
; d5 = cmd*2
; d6 = note.w
move.w n_funk(a2),d0
beq .1
bsr mt_updatefunk
.1: move.w morefx_tab(pc,d5.w),d0
jmp morefx_tab(pc,d0.w)
morefx_tab:
dc.w mt_pernop-morefx_tab,mt_pernop-morefx_tab,mt_pernop-morefx_tab
dc.w mt_pernop-morefx_tab,mt_pernop-morefx_tab,mt_pernop-morefx_tab
dc.w mt_pernop-morefx_tab,mt_pernop-morefx_tab,mt_pernop-morefx_tab
dc.w mt_pernop-morefx_tab ; $9
dc.w mt_pernop-morefx_tab
dc.w mt_posjump-morefx_tab ; $B
dc.w mt_volchange-morefx_tab
dc.w mt_patternbrk-morefx_tab ; $D
dc.w mt_e_cmds-morefx_tab
dc.w mt_setspeed-morefx_tab
ifeq MINIMAL
moreblockedfx:
; d6 = note.w | cmd.w
moveq #0,d4
move.b d6,d4 ; cmd argument
and.w #$0f00,d6
lsr.w #7,d6
move.w blmorefx_tab(pc,d6.w),d0
jmp blmorefx_tab(pc,d0.w)
blmorefx_tab:
dc.w mt_nop-blmorefx_tab,mt_nop-blmorefx_tab
dc.w mt_nop-blmorefx_tab,mt_nop-blmorefx_tab
dc.w mt_nop-blmorefx_tab,mt_nop-blmorefx_tab
dc.w mt_nop-blmorefx_tab,mt_nop-blmorefx_tab
dc.w mt_nop-blmorefx_tab,mt_nop-blmorefx_tab
dc.w mt_nop-blmorefx_tab
dc.w mt_posjump-blmorefx_tab ; $B
dc.w mt_nop-blmorefx_tab
dc.w mt_patternbrk-blmorefx_tab ; $D
dc.w blocked_e_cmds-blmorefx_tab
dc.w mt_setspeed-blmorefx_tab ; $F
endc ; !MINIMAL
mt_arpeggio:
; cmd 0 x y (x = first arpeggio offset, y = second arpeggio offset)
; d4 = xy
moveq #0,d0
move.b mt_Counter(a4),d0
move.b arptab(pc,d0.w),d0
beq mt_pernop ; step 0, just use normal period
bmi .1
; step 1, arpeggio by left nibble
lsr.b #4,d4
bra .2
; step 2, arpeggio by right nibble
.1: and.w #$000f,d4
; offset current note
.2: add.w d4,d4
add.w n_noteoff(a2),d4
cmp.w #2*36,d4
bhs .4
; set period with arpeggio offset from note table
move.l n_pertab(a2),a0
move.w (a0,d4.w),AUDPER(a5)
.4: rts
arptab:
dc.b 0,1,-1,0,1,-1,0,1,-1,0,1,-1,0,1,-1,0
dc.b 1,-1,0,1,-1,0,1,-1,0,1,-1,0,1,-1,0,1
mt_fineportaup:
; cmd E 1 x (subtract x from period)
; d0 = x
tst.b mt_Counter(a4)
beq do_porta_up
rts
mt_portaup:
; cmd 1 x x (subtract xx from period)
; d4 = xx
move.w d4,d0
do_porta_up:
move.w n_period(a2),d1
sub.w d0,d1
cmp.w #113,d1
bhs .1
moveq #113,d1
.1: move.w d1,n_period(a2)
move.w d1,AUDPER(a5)
rts
mt_fineportadn:
; cmd E 2 x (add x to period)
; d0 = x
tst.b mt_Counter(a4)
beq do_porta_down
rts
mt_portadown:
; cmd 2 x x (add xx to period)
; d4 = xx
move.w d4,d0
do_porta_down:
move.w n_period(a2),d1
add.w d0,d1
cmp.w #856,d1
bls .1
move.w #856,d1
.1: move.w d1,n_period(a2)
move.w d1,AUDPER(a5)
rts
mt_toneporta:
; cmd 3 x y (xy = tone portamento speed)
; d4 = xy
tst.b d4
beq mt_toneporta_nc
move.w d4,n_toneportspeed(a2)
move.b d7,n_cmdlo(a2)
mt_toneporta_nc:
move.w n_wantedperiod(a2),d1
beq .6
move.w n_toneportspeed(a2),d0
move.w n_period(a2),d2
cmp.w d1,d2
blo .2
; tone porta up
sub.w d0,d2
cmp.w d1,d2
bgt .3
move.w d1,d2
move.w d7,n_wantedperiod(a2)
bra .3
; tone porta down
.2: add.w d0,d2
cmp.w d1,d2
blt .3
move.w d1,d2
move.w d7,n_wantedperiod(a2)
.3: move.w d2,n_period(a2)
tst.b n_gliss(a2)
beq .5
; glissando: find nearest note for new period
move.l n_pertab(a2),a0
moveq #36-1,d0
moveq #-2,d1
.4: addq.w #2,d1
cmp.w (a0)+,d2
dbhs d0,.4
move.w d1,n_noteoff(a2) ; @@@ needed?
move.w -(a0),d2
.5: move.w d2,AUDPER(a5)
.6 rts
mt_vibrato:
; cmd 4 x y (x = speed, y = amplitude)
; d4 = xy
moveq #$0f,d2
and.b d4,d2
beq .1
move.b d2,n_vibratoamp(a2)
bra .2
.1: move.b n_vibratoamp(a2),d2
.2: lsr.b #4,d4
beq .3
move.b d4,n_vibratospd(a2)
bra mt_vibrato_nc
.3: move.b n_vibratospd(a2),d4
mt_vibrato_nc:
; calculate vibrato table offset: 64 * amplitude + (pos & 63)
lsl.w #6,d2
moveq #63,d0
and.b n_vibratopos(a2),d0
add.w d0,d2
ifne ENABLE_SAWRECT
; select vibrato waveform
moveq #3,d1
and.b n_vibratoctrl(a2),d1
beq .6
subq.b #1,d1
beq .5
; ctrl 2 & 3 select a rectangle vibrato
lea mt_VibratoRectTable(pc),a0
bra .9
; ctrl 1 selects a sawtooth vibrato
.5: lea mt_VibratoSawTable(pc),a0
bra .9
endc ; ENABLE_SAWRECT
; ctrl 0 selects a sine vibrato
.6: lea mt_VibratoSineTable(a4),a0
; add vibrato-offset to period
.9: move.b (a0,d2.w),d0
ext.w d0
add.w n_period(a2),d0
move.w d0,AUDPER(a5)
; increase vibratopos by speed
add.b d4,n_vibratopos(a2)
rts
mt_tonevolslide:
; cmd 5 x y (x = volume-up, y = volume-down)
; d4 = xy
pea mt_volumeslide(pc)
bra mt_toneporta_nc
mt_vibrvolslide:
; cmd 6 x y (x = volume-up, y = volume-down)
; d4 = xy
move.w d4,d3
move.b n_vibratoamp(a2),d2
move.b n_vibratospd(a2),d4
bsr mt_vibrato_nc
move.w d3,d4
bra mt_volumeslide
mt_tremolo:
; cmd 7 x y (x = speed, y = amplitude)
; d4 = xy
moveq #$0f,d2
and.b d4,d2
beq .1
move.b d2,n_tremoloamp(a2)
bra .2
.1: move.b n_tremoloamp(a2),d2
.2: lsr.b #4,d4
beq .3
move.b d4,n_tremolospd(a2)
bra .4
.3: move.b n_tremolospd(a2),d4
; calculate tremolo table offset: 64 * amplitude + (pos & 63)
.4: lsl.w #6,d2
moveq #63,d0
and.b n_tremolopos(a2),d0
add.w d0,d2
ifne ENABLE_SAWRECT
; select tremolo waveform
moveq #3,d1
and.b n_tremoloctrl(a2),d1
beq .6
subq.b #1,d1
beq .5
; ctrl 2 & 3 select a rectangle tremolo
lea mt_VibratoRectTable(pc),a0
bra .9
; ctrl 1 selects a sawtooth tremolo
.5: lea mt_VibratoSawTable(pc),a0
bra .9
endc ; ENABLE_SAWRECT
; ctrl 0 selects a sine tremolo
.6: lea mt_VibratoSineTable(a4),a0
; add tremolo-offset to volume
.9: move.w n_volume(a2),d0
add.b (a0,d2.w),d0
bpl .10
moveq #0,d0
.10: cmp.w #64,d0
bls .11
moveq #64,d0
.11: move.w n_period(a2),AUDPER(a5)
ifeq MINIMAL
move.l mt_MasterVolTab(a4),a0
move.b (a0,d0.w),d0
endc
move.w d0,AUDVOL(a5)
; increase tremolopos by speed
add.b d4,n_tremolopos(a2)
rts
mt_volumeslide:
; cmd A x y (x = volume-up, y = volume-down)
; d4 = xy
move.w n_volume(a2),d0
moveq #$0f,d1
and.b d4,d1
lsr.b #4,d4
beq vol_slide_down
; slide up, until 64
add.b d4,d0
vol_slide_up:
cmp.b #64,d0
bls set_vol
moveq #64,d0
bra set_vol
; slide down, until 0
vol_slide_down:
sub.b d1,d0
bpl set_vol
moveq #0,d0
set_vol:
move.w d0,n_volume(a2)
move.w n_period(a2),AUDPER(a5)
ifeq MINIMAL
move.l mt_MasterVolTab(a4),a0
move.b (a0,d0.w),d0
endc
move.w d0,AUDVOL(a5)
rts
mt_posjump:
; cmd B x y (xy = new song position)
; d4 = xy
move.b d4,d0
subq.b #1,d0
move.b d0,mt_SongPos(a4)
jump_pos0:
move.w d7,mt_PBreakPos(a4)
st mt_PosJumpFlag(a4)
rts
mt_volchange:
; cmd C x y (xy = new volume)
; d4 = xy
cmp.w #64,d4
bls .1
moveq #64,d4
.1: move.w d4,n_volume(a2)
ifeq MINIMAL
move.l mt_MasterVolTab(a4),a0
move.b (a0,d4.w),d4
endc
move.w d4,AUDVOL(a5)
rts
mt_patternbrk:
; cmd D x y (xy = break pos in decimal)
; d4 = xy
moveq #$0f,d0
and.w d4,d0
move.w d4,d1
lsr.w #4,d1
add.b mult10tab(pc,d1.w),d0
cmp.b #63,d0
bhi jump_pos0
lsl.w #4,d0
move.w d0,mt_PBreakPos(a4)
st mt_PosJumpFlag(a4)
rts
mult10tab:
dc.b 0,10,20,30,40,50,60,70,80,90,0,0,0,0,0,0
mt_setspeed:
; cmd F x y (xy<$20 new speed, xy>=$20 new tempo)
; d4 = xy
cmp.b #$20,d4
bhs .1
move.b d4,mt_Speed(a4)
beq _mt_end
rts
; set tempo (CIA only)
.1: and.w #$00ff,d4
move.l mt_timerval(a4),d0
divu d4,d0
move.b d0,CIAB+CIATALO
lsr.w #8,d0
move.b d0,CIAB+CIATAHI
rts
mt_e_cmds:
; cmd E x y (x=command, y=argument)
; d4 = xy
moveq #$0f,d0
and.w d4,d0 ; pass E-cmd argument in d0
move.w d4,d1
lsr.w #4,d1
add.w d1,d1
move.w ecmd_tab(pc,d1.w),d1
jmp ecmd_tab(pc,d1.w)
ecmd_tab:
dc.w mt_filter-ecmd_tab
dc.w mt_fineportaup-ecmd_tab
dc.w mt_fineportadn-ecmd_tab
dc.w mt_glissctrl-ecmd_tab
dc.w mt_vibratoctrl-ecmd_tab
dc.w mt_finetune-ecmd_tab
dc.w mt_jumploop-ecmd_tab
dc.w mt_tremoctrl-ecmd_tab
dc.w mt_e8-ecmd_tab
dc.w mt_retrignote-ecmd_tab
dc.w mt_volfineup-ecmd_tab
dc.w mt_volfinedn-ecmd_tab
dc.w mt_notecut-ecmd_tab
dc.w mt_notedelay-ecmd_tab
dc.w mt_patterndelay-ecmd_tab
dc.w mt_funk-ecmd_tab
blocked_e_cmds:
; cmd E x y (x=command, y=argument)
; d4 = xy
moveq #$0f,d0
and.w d4,d0 ; pass E-cmd argument in d0
move.w d4,d1
lsr.w #4,d1
add.w d1,d1
move.w blecmd_tab(pc,d1.w),d1
jmp blecmd_tab(pc,d1.w)
blecmd_tab:
dc.w mt_filter-blecmd_tab
dc.w mt_rts-blecmd_tab
dc.w mt_rts-blecmd_tab
dc.w mt_glissctrl-blecmd_tab
dc.w mt_vibratoctrl-blecmd_tab
dc.w mt_finetune-blecmd_tab
dc.w mt_jumploop-blecmd_tab
dc.w mt_tremoctrl-blecmd_tab
dc.w mt_e8-blecmd_tab
dc.w mt_rts-blecmd_tab
dc.w mt_rts-blecmd_tab
dc.w mt_rts-blecmd_tab
dc.w mt_rts-blecmd_tab
dc.w mt_rts-blecmd_tab
dc.w mt_patterndelay-blecmd_tab
dc.w mt_rts-blecmd_tab
mt_filter:
; cmd E 0 x (x=1 disable, x=0 enable)
; d0 = x
lsr.b #1,d0
bcs .1
bclr #2,CIAA+CIAPRA
rts
.1: bset #2,CIAA+CIAPRA
mt_rts:
rts
mt_glissctrl:
; cmd E 3 x (x gliss)
; d0 = x
move.b d0,n_gliss(a2)
rts
mt_vibratoctrl:
; cmd E 4 x (x = vibrato)
; d0 = x
move.b d0,n_vibratoctrl(a2)
rts
mt_finetune:
; cmd E 5 x (x = finetune)
; d0 = x
lea mt_PerFineTune(a4),a0 ;Antiriad: Finetune table is generated and in mt_data section
add.w d0,d0
add.w (a0,d0.w),a0
move.l a0,n_pertab(a2)
cmp.w #2*8,d0
shs n_minusft(a2)
rts
mt_jumploop:
; cmd E 6 x (x=0 loop start, else loop count)
; d0 = x
tst.b mt_Counter(a4)
bne .4
.1: tst.b d0
beq .3 ; set start
; otherwise we are at the end of the loop
subq.b #1,n_loopcount(a2)
beq .4 ; loop finished
bpl .2
; initialize loop counter
move.b d0,n_loopcount(a2)
; jump back to start of loop
.2: move.w n_pattpos(a2),mt_PBreakPos(a4)
st mt_PBreakFlag(a4)
rts
; remember start of loop position
.3: move.w mt_PatternPos(a4),n_pattpos(a2)
.4: rts
mt_tremoctrl:
; cmd E 7 x (x = tremolo)
; d0 = x
move.b d0,n_tremoloctrl(a2)
rts
mt_e8:
; cmd E 8 x (x = trigger value)
; d0 = x
move.b d0,mt_E8Trigger(a4)
rts
mt_retrignote:
; cmd E 9 x (x = retrigger count)
; d0 = x
tst.b d0
beq .1
; set new retrigger count when Counter=0
tst.b mt_Counter(a4)
bne .2
move.b d0,n_retrigcount(a2)
; avoid double retrigger, when Counter=0 and a note was set
move.w #$0fff,d2
and.w (a2),d2
beq do_retrigger
.1: rts
; check if retrigger count is reached
.2: subq.b #1,n_retrigcount(a2)
bne .1
move.b d0,n_retrigcount(a2) ; reset
do_retrigger:
; DMA off, set sample pointer and length
move.w n_dmabit(a2),d0
move.w d0,DMACON(a6)
move.l n_start(a2),AUDLC(a5)
move.w n_length(a2),AUDLEN(a5)
lea mt_dmaon(pc),a0
or.w d0,(a0)
rts
mt_volfineup:
; cmd E A x (x = volume add)
; d0 = x
tst.b mt_Counter(a4)
beq .1
rts
.1: add.w n_volume(a2),d0
bra vol_slide_up
mt_volfinedn:
; cmd E B x (x = volume sub)
; d0 = x
tst.b mt_Counter(a4)
beq .1
rts
.1: move.b d0,d1
move.w n_volume(a2),d0
bra vol_slide_down
mt_notecut:
; cmd E C x (x = counter to cut at)
; d0 = x
cmp.b mt_Counter(a4),d0
bne .1
move.w d7,n_volume(a2)
move.w d7,AUDVOL(a5)
.1: rts
mt_notedelay:
; cmd E D x (x = counter to retrigger at)
; d0 = x
cmp.b mt_Counter(a4),d0
bne .1
tst.w (a2) ; trigger note when given
bne .2
.1: rts
.2: move.w n_period(a2),AUDPER(a5)
bra do_retrigger
mt_patterndelay:
; cmd E E x (x = delay count)
; d0 = x
tst.b mt_Counter(a4)
bne .1
tst.b mt_PattDelTime2(a4)
bne .1
addq.b #1,d0
move.b d0,mt_PattDelTime(a4)
.1: rts
mt_funk:
; cmd E F x (x = funk speed)
; d0 = x
tst.b mt_Counter(a4)
bne .1
move.w d0,n_funk(a2)
bne mt_updatefunk
.1: rts
mt_updatefunk:
; d0 = funk speed
move.b mt_FunkTable(pc,d0.w),d0
add.b d0,n_funkoffset(a2)
bpl .2
move.b d7,n_funkoffset(a2)
move.l n_loopstart(a2),d0
moveq #0,d1
move.w n_replen(a2),d1
add.l d1,d1
add.l d0,d1
move.l n_wavestart(a2),a0
addq.l #1,a0
cmp.l d1,a0
blo .1
move.l d0,a0
.1: move.l a0,n_wavestart(a2)
not.b (a0)
.2: rts
mt_FunkTable:
dc.b 0,5,6,7,8,10,11,13,16,19,22,26,32,43,64,128
ifne ENABLE_SAWRECT
mt_VibratoSawTable:
dc.b 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
dc.b 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
dc.b 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
dc.b 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
dc.b 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
dc.b 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
dc.b -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
dc.b 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
dc.b 0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1
dc.b 2,2,2,2,2,2,2,2,3,3,3,3,3,3,3,3
dc.b -3,-3,-3,-3,-3,-3,-3,-3,-2,-2,-2,-2,-2,-2,-2,-2
dc.b -1,-1,-1,-1,-1,-1,-1,-1,0,0,0,0,0,0,0,0
dc.b 0,0,0,0,0,0,1,1,1,1,1,2,2,2,2,2
dc.b 3,3,3,3,3,3,4,4,4,4,4,5,5,5,5,5
dc.b -5,-5,-5,-5,-5,-5,-4,-4,-4,-4,-4,-3,-3,-3,-3,-3
dc.b -2,-2,-2,-2,-2,-2,-1,-1,-1,-1,-1,0,0,0,0,0
dc.b 0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3
dc.b 4,4,4,4,5,5,5,5,6,6,6,6,7,7,7,7
dc.b -7,-7,-7,-7,-6,-6,-6,-6,-5,-5,-5,-5,-4,-4,-4,-4
dc.b -3,-3,-3,-3,-2,-2,-2,-2,-1,-1,-1,-1,0,0,0,0
dc.b 0,0,0,0,1,1,1,2,2,2,3,3,3,4,4,4
dc.b 5,5,5,5,6,6,6,7,7,7,8,8,8,9,9,9
dc.b -9,-9,-9,-9,-8,-8,-8,-7,-7,-7,-6,-6,-6,-5,-5,-5
dc.b -4,-4,-4,-4,-3,-3,-3,-2,-2,-2,-1,-1,-1,0,0,0
dc.b 0,0,0,1,1,1,2,2,3,3,3,4,4,4,5,5
dc.b 6,6,6,7,7,7,8,8,9,9,9,10,10,10,11,11
dc.b -11,-11,-11,-10,-10,-10,-9,-9,-8,-8,-8,-7,-7,-7,-6,-6
dc.b -5,-5,-5,-4,-4,-4,-3,-3,-2,-2,-2,-1,-1,-1,0,0
dc.b 0,0,0,1,1,2,2,3,3,3,4,4,5,5,6,6
dc.b 7,7,7,8,8,9,9,10,10,10,11,11,12,12,13,13
dc.b -13,-13,-13,-12,-12,-11,-11,-10,-10,-10,-9,-9,-8,-8,-7,-7
dc.b -6,-6,-6,-5,-5,-4,-4,-3,-3,-3,-2,-2,-1,-1,0,0
dc.b 0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7
dc.b 8,8,9,9,10,10,11,11,12,12,13,13,14,14,15,15
dc.b -15,-15,-14,-14,-13,-13,-12,-12,-11,-11,-10,-10,-9,-9,-8,-8
dc.b -7,-7,-6,-6,-5,-5,-4,-4,-3,-3,-2,-2,-1,-1,0,0
dc.b 0,0,1,1,2,2,3,3,4,5,5,6,6,7,7,8
dc.b 9,9,10,10,11,11,12,12,13,14,14,15,15,16,16,17
dc.b -17,-17,-16,-16,-15,-15,-14,-13,-13,-12,-12,-11,-11,-10,-10,-9
dc.b -8,-8,-7,-7,-6,-6,-5,-4,-4,-3,-3,-2,-2,-1,-1,0
dc.b 0,0,1,1,2,3,3,4,5,5,6,6,7,8,8,9
dc.b 10,10,11,11,12,13,13,14,15,15,16,16,17,18,18,19
dc.b -19,-19,-18,-18,-17,-16,-16,-15,-14,-14,-13,-13,-12,-11,-11,-10
dc.b -9,-9,-8,-8,-7,-6,-6,-5,-4,-4,-3,-3,-2,-1,-1,0
dc.b 0,0,1,2,2,3,4,4,5,6,6,7,8,8,9,10
dc.b 11,11,12,13,13,14,15,15,16,17,17,18,19,19,20,21
dc.b -21,-21,-20,-19,-19,-18,-17,-17,-16,-15,-15,-14,-13,-12,-12,-11
dc.b -10,-10,-9,-8,-8,-7,-6,-6,-5,-4,-4,-3,-2,-1,-1,0
dc.b 0,0,1,2,3,3,4,5,6,6,7,8,9,9,10,11
dc.b 12,12,13,14,15,15,16,17,18,18,19,20,21,21,22,23
dc.b -23,-23,-22,-21,-20,-20,-19,-18,-17,-17,-16,-15,-14,-14,-13,-12
dc.b -11,-11,-10,-9,-8,-8,-7,-6,-5,-5,-4,-3,-2,-2,-1,0
dc.b 0,0,1,2,3,4,4,5,6,7,8,8,9,10,11,12
dc.b 13,13,14,15,16,17,17,18,19,20,21,21,22,23,24,25
dc.b -25,-25,-24,-23,-22,-21,-21,-20,-19,-18,-17,-16,-16,-15,-14,-13
dc.b -12,-12,-11,-10,-9,-8,-8,-7,-6,-5,-4,-3,-3,-2,-1,0
dc.b 0,0,1,2,3,4,5,6,7,7,8,9,10,11,12,13
dc.b 14,14,15,16,17,18,19,20,21,21,22,23,24,25,26,27
dc.b -27,-27,-26,-25,-24,-23,-22,-21,-20,-20,-19,-18,-17,-16,-15,-14
dc.b -13,-13,-12,-11,-10,-9,-8,-7,-6,-6,-5,-4,-3,-2,-1,0
dc.b 0,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14
dc.b 15,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29
dc.b -29,-28,-28,-27,-26,-25,-24,-23,-22,-21,-20,-19,-18,-17,-16,-15
dc.b -14,-13,-13,-12,-11,-10,-9,-8,-7,-6,-5,-4,-3,-2,-1,0
mt_VibratoRectTable:
dc.b 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
dc.b 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
dc.b 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
dc.b 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
dc.b 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
dc.b 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
dc.b -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
dc.b -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
dc.b 3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3
dc.b 3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3
dc.b -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3
dc.b -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3
dc.b 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5
dc.b 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5
dc.b -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5
dc.b -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5
dc.b 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7
dc.b 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7
dc.b -7,-7,-7,-7,-7,-7,-7,-7,-7,-7,-7,-7,-7,-7,-7,-7
dc.b -7,-7,-7,-7,-7,-7,-7,-7,-7,-7,-7,-7,-7,-7,-7,-7
dc.b 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9
dc.b 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9
dc.b -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9
dc.b -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9
dc.b 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11
dc.b 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11
dc.b -11,-11,-11,-11,-11,-11,-11,-11,-11,-11,-11,-11,-11,-11,-11,-11
dc.b -11,-11,-11,-11,-11,-11,-11,-11,-11,-11,-11,-11,-11,-11,-11,-11
dc.b 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13
dc.b 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13
dc.b -13,-13,-13,-13,-13,-13,-13,-13,-13,-13,-13,-13,-13,-13,-13,-13
dc.b -13,-13,-13,-13,-13,-13,-13,-13,-13,-13,-13,-13,-13,-13,-13,-13
dc.b 15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15
dc.b 15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15
dc.b -15,-15,-15,-15,-15,-15,-15,-15,-15,-15,-15,-15,-15,-15,-15,-15
dc.b -15,-15,-15,-15,-15,-15,-15,-15,-15,-15,-15,-15,-15,-15,-15,-15
dc.b 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17
dc.b 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17
dc.b -17,-17,-17,-17,-17,-17,-17,-17,-17,-17,-17,-17,-17,-17,-17,-17
dc.b -17,-17,-17,-17,-17,-17,-17,-17,-17,-17,-17,-17,-17,-17,-17,-17
dc.b 19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19
dc.b 19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19
dc.b -19,-19,-19,-19,-19,-19,-19,-19,-19,-19,-19,-19,-19,-19,-19,-19
dc.b -19,-19,-19,-19,-19,-19,-19,-19,-19,-19,-19,-19,-19,-19,-19,-19
dc.b 21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21
dc.b 21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21
dc.b -21,-21,-21,-21,-21,-21,-21,-21,-21,-21,-21,-21,-21,-21,-21,-21
dc.b -21,-21,-21,-21,-21,-21,-21,-21,-21,-21,-21,-21,-21,-21,-21,-21
dc.b 23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23
dc.b 23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23
dc.b -23,-23,-23,-23,-23,-23,-23,-23,-23,-23,-23,-23,-23,-23,-23,-23
dc.b -23,-23,-23,-23,-23,-23,-23,-23,-23,-23,-23,-23,-23,-23,-23,-23
dc.b 25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,25
dc.b 25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,25
dc.b -25,-25,-25,-25,-25,-25,-25,-25,-25,-25,-25,-25,-25,-25,-25,-25
dc.b -25,-25,-25,-25,-25,-25,-25,-25,-25,-25,-25,-25,-25,-25,-25,-25
dc.b 27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27
dc.b 27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27
dc.b -27,-27,-27,-27,-27,-27,-27,-27,-27,-27,-27,-27,-27,-27,-27,-27
dc.b -27,-27,-27,-27,-27,-27,-27,-27,-27,-27,-27,-27,-27,-27,-27,-27
dc.b 29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29
dc.b 29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29
dc.b -29,-29,-29,-29,-29,-29,-29,-29,-29,-29,-29,-29,-29,-29,-29,-29
dc.b -29,-29,-29,-29,-29,-29,-29,-29,-29,-29,-29,-29,-29,-29,-29,-29
endc ; ENABLE_SAWRECT
ifeq MINIMAL
MasterVolTab0:
dc.b 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
dc.b 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
dc.b 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
dc.b 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
dc.b 0
MasterVolTab1:
dc.b 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
dc.b 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
dc.b 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
dc.b 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
dc.b 1
MasterVolTab2:
dc.b 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
dc.b 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
dc.b 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
dc.b 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
dc.b 2
MasterVolTab3:
dc.b 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
dc.b 0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1
dc.b 1,1,1,1,1,1,1,1,1,1,1,2,2,2,2,2
dc.b 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2
dc.b 3
MasterVolTab4:
dc.b 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
dc.b 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
dc.b 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2
dc.b 3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3
dc.b 4
MasterVolTab5:
dc.b 0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1
dc.b 1,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2
dc.b 2,2,2,2,2,2,2,3,3,3,3,3,3,3,3,3
dc.b 3,3,3,3,4,4,4,4,4,4,4,4,4,4,4,4
dc.b 5
MasterVolTab6:
dc.b 0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1
dc.b 1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,2
dc.b 3,3,3,3,3,3,3,3,3,3,3,4,4,4,4,4
dc.b 4,4,4,4,4,4,5,5,5,5,5,5,5,5,5,5
dc.b 6
MasterVolTab7:
dc.b 0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1
dc.b 1,1,1,2,2,2,2,2,2,2,2,2,3,3,3,3
dc.b 3,3,3,3,3,4,4,4,4,4,4,4,4,4,5,5
dc.b 5,5,5,5,5,5,5,6,6,6,6,6,6,6,6,6
dc.b 7
MasterVolTab8:
dc.b 0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1
dc.b 2,2,2,2,2,2,2,2,3,3,3,3,3,3,3,3
dc.b 4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5
dc.b 6,6,6,6,6,6,6,6,7,7,7,7,7,7,7,7
dc.b 8
MasterVolTab9:
dc.b 0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,2
dc.b 2,2,2,2,2,2,3,3,3,3,3,3,3,4,4,4
dc.b 4,4,4,4,5,5,5,5,5,5,5,6,6,6,6,6
dc.b 6,6,7,7,7,7,7,7,7,8,8,8,8,8,8,8
dc.b 9
MasterVolTab10:
dc.b 0,0,0,0,0,0,0,1,1,1,1,1,1,2,2,2
dc.b 2,2,2,2,3,3,3,3,3,3,4,4,4,4,4,4
dc.b 5,5,5,5,5,5,5,6,6,6,6,6,6,7,7,7
dc.b 7,7,7,7,8,8,8,8,8,8,9,9,9,9,9,9
dc.b 10
MasterVolTab11:
dc.b 0,0,0,0,0,0,1,1,1,1,1,1,2,2,2,2
dc.b 2,2,3,3,3,3,3,3,4,4,4,4,4,4,5,5
dc.b 5,5,5,6,6,6,6,6,6,7,7,7,7,7,7,8
dc.b 8,8,8,8,8,9,9,9,9,9,9,10,10,10,10,10
dc.b 11
MasterVolTab12:
dc.b 0,0,0,0,0,0,1,1,1,1,1,2,2,2,2,2
dc.b 3,3,3,3,3,3,4,4,4,4,4,5,5,5,5,5
dc.b 6,6,6,6,6,6,7,7,7,7,7,8,8,8,8,8
dc.b 9,9,9,9,9,9,10,10,10,10,10,11,11,11,11,11
dc.b 12
MasterVolTab13:
dc.b 0,0,0,0,0,1,1,1,1,1,2,2,2,2,2,3
dc.b 3,3,3,3,4,4,4,4,4,5,5,5,5,5,6,6
dc.b 6,6,6,7,7,7,7,7,8,8,8,8,8,9,9,9
dc.b 9,9,10,10,10,10,10,11,11,11,11,11,12,12,12,12
dc.b 13
MasterVolTab14:
dc.b 0,0,0,0,0,1,1,1,1,1,2,2,2,2,3,3
dc.b 3,3,3,4,4,4,4,5,5,5,5,5,6,6,6,6
dc.b 7,7,7,7,7,8,8,8,8,8,9,9,9,9,10,10
dc.b 10,10,10,11,11,11,11,12,12,12,12,12,13,13,13,13
dc.b 14
MasterVolTab15:
dc.b 0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3
dc.b 3,3,4,4,4,4,5,5,5,5,6,6,6,6,7,7
dc.b 7,7,7,8,8,8,8,9,9,9,9,10,10,10,10,11
dc.b 11,11,11,11,12,12,12,12,13,13,13,13,14,14,14,14
dc.b 15
MasterVolTab16:
dc.b 0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3
dc.b 4,4,4,4,5,5,5,5,6,6,6,6,7,7,7,7
dc.b 8,8,8,8,9,9,9,9,10,10,10,10,11,11,11,11
dc.b 12,12,12,12,13,13,13,13,14,14,14,14,15,15,15,15
dc.b 16
MasterVolTab17:
dc.b 0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3
dc.b 4,4,4,5,5,5,5,6,6,6,6,7,7,7,7,8
dc.b 8,8,9,9,9,9,10,10,10,10,11,11,11,11,12,12
dc.b 12,13,13,13,13,14,14,14,14,15,15,15,15,16,16,16
dc.b 17
MasterVolTab18:
dc.b 0,0,0,0,1,1,1,1,2,2,2,3,3,3,3,4
dc.b 4,4,5,5,5,5,6,6,6,7,7,7,7,8,8,8
dc.b 9,9,9,9,10,10,10,10,11,11,11,12,12,12,12,13
dc.b 13,13,14,14,14,14,15,15,15,16,16,16,16,17,17,17
dc.b 18
MasterVolTab19:
dc.b 0,0,0,0,1,1,1,2,2,2,2,3,3,3,4,4
dc.b 4,5,5,5,5,6,6,6,7,7,7,8,8,8,8,9
dc.b 9,9,10,10,10,10,11,11,11,12,12,12,13,13,13,13
dc.b 14,14,14,15,15,15,16,16,16,16,17,17,17,18,18,18
dc.b 19
MasterVolTab20:
dc.b 0,0,0,0,1,1,1,2,2,2,3,3,3,4,4,4
dc.b 5,5,5,5,6,6,6,7,7,7,8,8,8,9,9,9
dc.b 10,10,10,10,11,11,11,12,12,12,13,13,13,14,14,14
dc.b 15,15,15,15,16,16,16,17,17,17,18,18,18,19,19,19
dc.b 20
MasterVolTab21:
dc.b 0,0,0,0,1,1,1,2,2,2,3,3,3,4,4,4
dc.b 5,5,5,6,6,6,7,7,7,8,8,8,9,9,9,10
dc.b 10,10,11,11,11,12,12,12,13,13,13,14,14,14,15,15
dc.b 15,16,16,16,17,17,17,18,18,18,19,19,19,20,20,20
dc.b 21
MasterVolTab22:
dc.b 0,0,0,1,1,1,2,2,2,3,3,3,4,4,4,5
dc.b 5,5,6,6,6,7,7,7,8,8,8,9,9,9,10,10
dc.b 11,11,11,12,12,12,13,13,13,14,14,14,15,15,15,16
dc.b 16,16,17,17,17,18,18,18,19,19,19,20,20,20,21,21
dc.b 22
MasterVolTab23:
dc.b 0,0,0,1,1,1,2,2,2,3,3,3,4,4,5,5
dc.b 5,6,6,6,7,7,7,8,8,8,9,9,10,10,10,11
dc.b 11,11,12,12,12,13,13,14,14,14,15,15,15,16,16,16
dc.b 17,17,17,18,18,19,19,19,20,20,20,21,21,21,22,22
dc.b 23
MasterVolTab24:
dc.b 0,0,0,1,1,1,2,2,3,3,3,4,4,4,5,5
dc.b 6,6,6,7,7,7,8,8,9,9,9,10,10,10,11,11
dc.b 12,12,12,13,13,13,14,14,15,15,15,16,16,16,17,17
dc.b 18,18,18,19,19,19,20,20,21,21,21,22,22,22,23,23
dc.b 24
MasterVolTab25:
dc.b 0,0,0,1,1,1,2,2,3,3,3,4,4,5,5,5
dc.b 6,6,7,7,7,8,8,8,9,9,10,10,10,11,11,12
dc.b 12,12,13,13,14,14,14,15,15,16,16,16,17,17,17,18
dc.b 18,19,19,19,20,20,21,21,21,22,22,23,23,23,24,24
dc.b 25
MasterVolTab26:
dc.b 0,0,0,1,1,2,2,2,3,3,4,4,4,5,5,6
dc.b 6,6,7,7,8,8,8,9,9,10,10,10,11,11,12,12
dc.b 13,13,13,14,14,15,15,15,16,16,17,17,17,18,18,19
dc.b 19,19,20,20,21,21,21,22,22,23,23,23,24,24,25,25
dc.b 26
MasterVolTab27:
dc.b 0,0,0,1,1,2,2,2,3,3,4,4,5,5,5,6
dc.b 6,7,7,8,8,8,9,9,10,10,10,11,11,12,12,13
dc.b 13,13,14,14,15,15,16,16,16,17,17,18,18,18,19,19
dc.b 20,20,21,21,21,22,22,23,23,24,24,24,25,25,26,26
dc.b 27
MasterVolTab28:
dc.b 0,0,0,1,1,2,2,3,3,3,4,4,5,5,6,6
dc.b 7,7,7,8,8,9,9,10,10,10,11,11,12,12,13,13
dc.b 14,14,14,15,15,16,16,17,17,17,18,18,19,19,20,20
dc.b 21,21,21,22,22,23,23,24,24,24,25,25,26,26,27,27
dc.b 28
MasterVolTab29:
dc.b 0,0,0,1,1,2,2,3,3,4,4,4,5,5,6,6
dc.b 7,7,8,8,9,9,9,10,10,11,11,12,12,13,13,14
dc.b 14,14,15,15,16,16,17,17,18,18,19,19,19,20,20,21
dc.b 21,22,22,23,23,24,24,24,25,25,26,26,27,27,28,28
dc.b 29
MasterVolTab30:
dc.b 0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7
dc.b 7,7,8,8,9,9,10,10,11,11,12,12,13,13,14,14
dc.b 15,15,15,16,16,17,17,18,18,19,19,20,20,21,21,22
dc.b 22,22,23,23,24,24,25,25,26,26,27,27,28,28,29,29
dc.b 30
MasterVolTab31:
dc.b 0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7
dc.b 7,8,8,9,9,10,10,11,11,12,12,13,13,14,14,15
dc.b 15,15,16,16,17,17,18,18,19,19,20,20,21,21,22,22
dc.b 23,23,24,24,25,25,26,26,27,27,28,28,29,29,30,30
dc.b 31
MasterVolTab32:
dc.b 0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7
dc.b 8,8,9,9,10,10,11,11,12,12,13,13,14,14,15,15
dc.b 16,16,17,17,18,18,19,19,20,20,21,21,22,22,23,23
dc.b 24,24,25,25,26,26,27,27,28,28,29,29,30,30,31,31
dc.b 32
MasterVolTab33:
dc.b 0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7
dc.b 8,8,9,9,10,10,11,11,12,12,13,13,14,14,15,15
dc.b 16,17,17,18,18,19,19,20,20,21,21,22,22,23,23,24
dc.b 24,25,25,26,26,27,27,28,28,29,29,30,30,31,31,32
dc.b 33
MasterVolTab34:
dc.b 0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7
dc.b 8,9,9,10,10,11,11,12,12,13,13,14,14,15,15,16
dc.b 17,17,18,18,19,19,20,20,21,21,22,22,23,23,24,24
dc.b 25,26,26,27,27,28,28,29,29,30,30,31,31,32,32,33
dc.b 34
MasterVolTab35:
dc.b 0,0,1,1,2,2,3,3,4,4,5,6,6,7,7,8
dc.b 8,9,9,10,10,11,12,12,13,13,14,14,15,15,16,16
dc.b 17,18,18,19,19,20,20,21,21,22,22,23,24,24,25,25
dc.b 26,26,27,27,28,28,29,30,30,31,31,32,32,33,33,34
dc.b 35
MasterVolTab36:
dc.b 0,0,1,1,2,2,3,3,4,5,5,6,6,7,7,8
dc.b 9,9,10,10,11,11,12,12,13,14,14,15,15,16,16,17
dc.b 18,18,19,19,20,20,21,21,22,23,23,24,24,25,25,26
dc.b 27,27,28,28,29,29,30,30,31,32,32,33,33,34,34,35
dc.b 36
MasterVolTab37:
dc.b 0,0,1,1,2,2,3,4,4,5,5,6,6,7,8,8
dc.b 9,9,10,10,11,12,12,13,13,14,15,15,16,16,17,17
dc.b 18,19,19,20,20,21,21,22,23,23,24,24,25,26,26,27
dc.b 27,28,28,29,30,30,31,31,32,32,33,34,34,35,35,36
dc.b 37
MasterVolTab38:
dc.b 0,0,1,1,2,2,3,4,4,5,5,6,7,7,8,8
dc.b 9,10,10,11,11,12,13,13,14,14,15,16,16,17,17,18
dc.b 19,19,20,20,21,21,22,23,23,24,24,25,26,26,27,27
dc.b 28,29,29,30,30,31,32,32,33,33,34,35,35,36,36,37
dc.b 38
MasterVolTab39:
dc.b 0,0,1,1,2,3,3,4,4,5,6,6,7,7,8,9
dc.b 9,10,10,11,12,12,13,14,14,15,15,16,17,17,18,18
dc.b 19,20,20,21,21,22,23,23,24,24,25,26,26,27,28,28
dc.b 29,29,30,31,31,32,32,33,34,34,35,35,36,37,37,38
dc.b 39
MasterVolTab40:
dc.b 0,0,1,1,2,3,3,4,5,5,6,6,7,8,8,9
dc.b 10,10,11,11,12,13,13,14,15,15,16,16,17,18,18,19
dc.b 20,20,21,21,22,23,23,24,25,25,26,26,27,28,28,29
dc.b 30,30,31,31,32,33,33,34,35,35,36,36,37,38,38,39
dc.b 40
MasterVolTab41:
dc.b 0,0,1,1,2,3,3,4,5,5,6,7,7,8,8,9
dc.b 10,10,11,12,12,13,14,14,15,16,16,17,17,18,19,19
dc.b 20,21,21,22,23,23,24,24,25,26,26,27,28,28,29,30
dc.b 30,31,32,32,33,33,34,35,35,36,37,37,38,39,39,40
dc.b 41
MasterVolTab42:
dc.b 0,0,1,1,2,3,3,4,5,5,6,7,7,8,9,9
dc.b 10,11,11,12,13,13,14,15,15,16,17,17,18,19,19,20
dc.b 21,21,22,22,23,24,24,25,26,26,27,28,28,29,30,30
dc.b 31,32,32,33,34,34,35,36,36,37,38,38,39,40,40,41
dc.b 42
MasterVolTab43:
dc.b 0,0,1,2,2,3,4,4,5,6,6,7,8,8,9,10
dc.b 10,11,12,12,13,14,14,15,16,16,17,18,18,19,20,20
dc.b 21,22,22,23,24,24,25,26,26,27,28,28,29,30,30,31
dc.b 32,32,33,34,34,35,36,36,37,38,38,39,40,40,41,42
dc.b 43
MasterVolTab44:
dc.b 0,0,1,2,2,3,4,4,5,6,6,7,8,8,9,10
dc.b 11,11,12,13,13,14,15,15,16,17,17,18,19,19,20,21
dc.b 22,22,23,24,24,25,26,26,27,28,28,29,30,30,31,32
dc.b 33,33,34,35,35,36,37,37,38,39,39,40,41,41,42,43
dc.b 44
MasterVolTab45:
dc.b 0,0,1,2,2,3,4,4,5,6,7,7,8,9,9,10
dc.b 11,11,12,13,14,14,15,16,16,17,18,18,19,20,21,21
dc.b 22,23,23,24,25,26,26,27,28,28,29,30,30,31,32,33
dc.b 33,34,35,35,36,37,37,38,39,40,40,41,42,42,43,44
dc.b 45
MasterVolTab46:
dc.b 0,0,1,2,2,3,4,5,5,6,7,7,8,9,10,10
dc.b 11,12,12,13,14,15,15,16,17,17,18,19,20,20,21,22
dc.b 23,23,24,25,25,26,27,28,28,29,30,30,31,32,33,33
dc.b 34,35,35,36,37,38,38,39,40,40,41,42,43,43,44,45
dc.b 46
MasterVolTab47:
dc.b 0,0,1,2,2,3,4,5,5,6,7,8,8,9,10,11
dc.b 11,12,13,13,14,15,16,16,17,18,19,19,20,21,22,22
dc.b 23,24,24,25,26,27,27,28,29,30,30,31,32,33,33,34
dc.b 35,35,36,37,38,38,39,40,41,41,42,43,44,44,45,46
dc.b 47
MasterVolTab48:
dc.b 0,0,1,2,3,3,4,5,6,6,7,8,9,9,10,11
dc.b 12,12,13,14,15,15,16,17,18,18,19,20,21,21,22,23
dc.b 24,24,25,26,27,27,28,29,30,30,31,32,33,33,34,35
dc.b 36,36,37,38,39,39,40,41,42,42,43,44,45,45,46,47
dc.b 48
MasterVolTab49:
dc.b 0,0,1,2,3,3,4,5,6,6,7,8,9,9,10,11
dc.b 12,13,13,14,15,16,16,17,18,19,19,20,21,22,22,23
dc.b 24,25,26,26,27,28,29,29,30,31,32,32,33,34,35,35
dc.b 36,37,38,39,39,40,41,42,42,43,44,45,45,46,47,48
dc.b 49
MasterVolTab50:
dc.b 0,0,1,2,3,3,4,5,6,7,7,8,9,10,10,11
dc.b 12,13,14,14,15,16,17,17,18,19,20,21,21,22,23,24
dc.b 25,25,26,27,28,28,29,30,31,32,32,33,34,35,35,36
dc.b 37,38,39,39,40,41,42,42,43,44,45,46,46,47,48,49
dc.b 50
MasterVolTab51:
dc.b 0,0,1,2,3,3,4,5,6,7,7,8,9,10,11,11
dc.b 12,13,14,15,15,16,17,18,19,19,20,21,22,23,23,24
dc.b 25,26,27,27,28,29,30,31,31,32,33,34,35,35,36,37
dc.b 38,39,39,40,41,42,43,43,44,45,46,47,47,48,49,50
dc.b 51
MasterVolTab52:
dc.b 0,0,1,2,3,4,4,5,6,7,8,8,9,10,11,12
dc.b 13,13,14,15,16,17,17,18,19,20,21,21,22,23,24,25
dc.b 26,26,27,28,29,30,30,31,32,33,34,34,35,36,37,38
dc.b 39,39,40,41,42,43,43,44,45,46,47,47,48,49,50,51
dc.b 52
MasterVolTab53:
dc.b 0,0,1,2,3,4,4,5,6,7,8,9,9,10,11,12
dc.b 13,14,14,15,16,17,18,19,19,20,21,22,23,24,24,25
dc.b 26,27,28,28,29,30,31,32,33,33,34,35,36,37,38,38
dc.b 39,40,41,42,43,43,44,45,46,47,48,48,49,50,51,52
dc.b 53
MasterVolTab54:
dc.b 0,0,1,2,3,4,5,5,6,7,8,9,10,10,11,12
dc.b 13,14,15,16,16,17,18,19,20,21,21,22,23,24,25,26
dc.b 27,27,28,29,30,31,32,32,33,34,35,36,37,37,38,39
dc.b 40,41,42,43,43,44,45,46,47,48,48,49,50,51,52,53
dc.b 54
MasterVolTab55:
dc.b 0,0,1,2,3,4,5,6,6,7,8,9,10,11,12,12
dc.b 13,14,15,16,17,18,18,19,20,21,22,23,24,24,25,26
dc.b 27,28,29,30,30,31,32,33,34,35,36,36,37,38,39,40
dc.b 41,42,42,43,44,45,46,47,48,48,49,50,51,52,53,54
dc.b 55
MasterVolTab56:
dc.b 0,0,1,2,3,4,5,6,7,7,8,9,10,11,12,13
dc.b 14,14,15,16,17,18,19,20,21,21,22,23,24,25,26,27
dc.b 28,28,29,30,31,32,33,34,35,35,36,37,38,39,40,41
dc.b 42,42,43,44,45,46,47,48,49,49,50,51,52,53,54,55
dc.b 56
MasterVolTab57:
dc.b 0,0,1,2,3,4,5,6,7,8,8,9,10,11,12,13
dc.b 14,15,16,16,17,18,19,20,21,22,23,24,24,25,26,27
dc.b 28,29,30,31,32,32,33,34,35,36,37,38,39,40,40,41
dc.b 42,43,44,45,46,47,48,48,49,50,51,52,53,54,55,56
dc.b 57
MasterVolTab58:
dc.b 0,0,1,2,3,4,5,6,7,8,9,9,10,11,12,13
dc.b 14,15,16,17,18,19,19,20,21,22,23,24,25,26,27,28
dc.b 29,29,30,31,32,33,34,35,36,37,38,38,39,40,41,42
dc.b 43,44,45,46,47,48,48,49,50,51,52,53,54,55,56,57
dc.b 58
MasterVolTab59:
dc.b 0,0,1,2,3,4,5,6,7,8,9,10,11,11,12,13
dc.b 14,15,16,17,18,19,20,21,22,23,23,24,25,26,27,28
dc.b 29,30,31,32,33,34,35,35,36,37,38,39,40,41,42,43
dc.b 44,45,46,47,47,48,49,50,51,52,53,54,55,56,57,58
dc.b 59
MasterVolTab60:
dc.b 0,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14
dc.b 15,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29
dc.b 30,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44
dc.b 45,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59
dc.b 60
MasterVolTab61:
dc.b 0,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14
dc.b 15,16,17,18,19,20,20,21,22,23,24,25,26,27,28,29
dc.b 30,31,32,33,34,35,36,37,38,39,40,40,41,42,43,44
dc.b 45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60
dc.b 61
MasterVolTab62:
dc.b 0,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14
dc.b 15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30
dc.b 31,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45
dc.b 46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61
dc.b 62
MasterVolTab63:
dc.b 0,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14
dc.b 15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30
dc.b 31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46
dc.b 47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62
dc.b 63
MasterVolTab64:
dc.b 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15
dc.b 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31
dc.b 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47
dc.b 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63
dc.b 64
even
endc ; !MINIMAL
*****************************************************************************
section __MERGED,bss
rsreset
; Antiriad - put this at the start of mt_data to avoid alignment issues with the rs.b near the end
mt_PerFineTune rs.w 16
mt_PeriodTable rs.w 0
mt_Tuning0 rs.w 36
mt_Tuning1 rs.w 36
mt_Tuning2 rs.w 36
mt_Tuning3 rs.w 36
mt_Tuning4 rs.w 36
mt_Tuning5 rs.w 36
mt_Tuning6 rs.w 36
mt_Tuning7 rs.w 36
mt_TuningM8 rs.w 36
mt_TuningM7 rs.w 36
mt_TuningM6 rs.w 36
mt_TuningM5 rs.w 36
mt_TuningM4 rs.w 36
mt_TuningM3 rs.w 36
mt_TuningM2 rs.w 36
mt_TuningM1 rs.w 36
; Antiriad - end of periodtable
; Antiriad - vibrato sine table
mt_VibratoSineTable rs.b 16*64
mt_VibratoSineTable_End rs.b 0
; Antiriad - end of vibrato sine table
mt_chan1 rs.b n_sizeof
mt_chan2 rs.b n_sizeof
mt_chan3 rs.b n_sizeof
mt_chan4 rs.b n_sizeof
mt_SampleStarts rs.l 31
mt_mod rs.l 1
mt_oldLev6 rs.l 1
mt_timerval rs.l 1
mt_oldtimers rs.b 4
mt_Lev6Int rs.l 1
mt_Lev6Ena rs.w 1
mt_PatternPos rs.w 1
mt_PBreakPos rs.w 1
mt_PosJumpFlag rs.b 1
mt_PBreakFlag rs.b 1
mt_Speed rs.b 1
mt_Counter rs.b 1
mt_SongPos rs.b 1
mt_PattDelTime rs.b 1
mt_PattDelTime2 rs.b 1
ifeq MINIMAL
mt_SilCntValid rs.b 1
mt_MasterVolTab rs.l 1
endc ; !MINIMAL
mt_Enable rs.b 1 ; exported as _mt_Enable
mt_E8Trigger rs.b 1 ; exported as _mt_E8Trigger
ifeq MINIMAL
mt_MusicChannels rs.b 1 ; exported as _mt_MusicChannels
mt_SongEnd rs.b 1 ; exported as _mt_SongEnd
endc ; !MINIMAL
ifne ENABLE_VUMETER
mt_VUMeter rs.b 1 ; exported as _mt_VUMeter
endc ;ENABLE_VUMETER
mt_data:
ds.b mt_Enable
xdef _mt_Enable
_mt_Enable:
ds.b 1
xdef _mt_E8Trigger
_mt_E8Trigger:
ds.b 1
ifeq MINIMAL
xdef _mt_MusicChannels
_mt_MusicChannels:
ds.b 1
xdef _mt_SongEnd
_mt_SongEnd:
ds.b 1
endc ; !MINIMAL
ifne ENABLE_VUMETER
xdef _mt_VUMeter
_mt_VUMeter:
ds.b 1
endc ;ENABLE_VUMETER
|
; A203990: Symmetric matrix based on f(i,j) = (i+j)*min(i,j), by antidiagonals.
; Submitted by Christian Krause
; 2,3,3,4,8,4,5,10,10,5,6,12,18,12,6,7,14,21,21,14,7,8,16,24,32,24,16,8,9,18,27,36,36,27,18,9,10,20,30,40,50,40,30,20,10,11,22,33,44,55,55,44,33,22,11,12,24,36,48,60,72,60,48,36,24,12,13,26,39,52,65,78,78,65,52,39,26,13,14,28,42,56,70,84,98,84,70,56,42,28,14,15,30,45,60,75,90,105,105,90
lpb $0
add $1,1
sub $0,$1
mov $2,$1
sub $2,$0
lpe
min $0,$2
add $1,2
mov $2,$1
mul $2,$0
add $2,$1
mov $0,$2
|
.global s_prepare_buffers
s_prepare_buffers:
push %r11
push %r12
push %r15
push %r9
push %rax
push %rbx
lea addresses_normal_ht+0xc3db, %r15
nop
cmp $24214, %r9
mov (%r15), %rax
and $40312, %r12
lea addresses_UC_ht+0x6bdb, %r11
nop
nop
nop
nop
add $4549, %rbx
movw $0x6162, (%r11)
nop
cmp $17506, %rbx
lea addresses_D_ht+0x151db, %rbx
nop
nop
nop
nop
nop
cmp %r15, %r15
vmovups (%rbx), %ymm5
vextracti128 $0, %ymm5, %xmm5
vpextrq $0, %xmm5, %r11
nop
nop
nop
and $39734, %r9
pop %rbx
pop %rax
pop %r9
pop %r15
pop %r12
pop %r11
ret
.global s_faulty_load
s_faulty_load:
push %r10
push %r12
push %r14
push %r9
push %rbp
// Faulty Load
lea addresses_A+0x9bdb, %r9
nop
nop
xor %r12, %r12
mov (%r9), %r14w
lea oracles, %r10
and $0xff, %r14
shlq $12, %r14
mov (%r10,%r14,1), %r14
pop %rbp
pop %r9
pop %r14
pop %r12
pop %r10
ret
/*
<gen_faulty_load>
[REF]
{'src': {'congruent': 0, 'AVXalign': True, 'same': True, 'size': 32, 'NT': True, 'type': 'addresses_A'}, 'OP': 'LOAD'}
[Faulty Load]
{'src': {'congruent': 0, 'AVXalign': False, 'same': True, 'size': 2, 'NT': False, 'type': 'addresses_A'}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'src': {'congruent': 11, 'AVXalign': False, 'same': False, 'size': 8, 'NT': False, 'type': 'addresses_normal_ht'}, 'OP': 'LOAD'}
{'OP': 'STOR', 'dst': {'congruent': 11, 'AVXalign': False, 'same': False, 'size': 2, 'NT': False, 'type': 'addresses_UC_ht'}}
{'src': {'congruent': 7, 'AVXalign': False, 'same': False, 'size': 32, 'NT': False, 'type': 'addresses_D_ht'}, 'OP': 'LOAD'}
{'00': 21829}
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
*/
|
; A021918: Decimal expansion of 1/914.
; Submitted by Jon Maiga
; 0,0,1,0,9,4,0,9,1,9,0,3,7,1,9,9,1,2,4,7,2,6,4,7,7,0,2,4,0,7,0,0,2,1,8,8,1,8,3,8,0,7,4,3,9,8,2,4,9,4,5,2,9,5,4,0,4,8,1,4,0,0,4,3,7,6,3,6,7,6,1,4,8,7,9,6,4,9,8,9,0,5,9,0,8,0,9,6,2,8,0,0,8,7,5,2,7,3,5
seq $0,199685 ; a(n) = 5*10^n+1.
div $0,457
mod $0,10
|
.global s_prepare_buffers
s_prepare_buffers:
push %r10
push %r11
push %r12
push %r14
push %rax
push %rbp
push %rcx
push %rdi
push %rsi
lea addresses_A_ht+0x10a93, %rbp
clflush (%rbp)
nop
sub $10691, %r11
movups (%rbp), %xmm1
vpextrq $0, %xmm1, %rcx
nop
nop
nop
sub %r14, %r14
lea addresses_WC_ht+0x181b3, %r10
nop
nop
nop
add $55563, %r12
movw $0x6162, (%r10)
nop
nop
nop
nop
nop
add %r12, %r12
lea addresses_WT_ht+0x34d3, %rsi
lea addresses_WT_ht+0xdb, %rdi
mfence
mov $9, %rcx
rep movsb
nop
nop
nop
and %rcx, %rcx
lea addresses_WT_ht+0x1ea93, %rsi
lea addresses_A_ht+0xc4fd, %rdi
nop
cmp $52416, %r12
mov $97, %rcx
rep movsw
dec %r12
pop %rsi
pop %rdi
pop %rcx
pop %rbp
pop %rax
pop %r14
pop %r12
pop %r11
pop %r10
ret
.global s_faulty_load
s_faulty_load:
push %r10
push %r13
push %r8
push %r9
push %rcx
push %rdi
push %rsi
// REPMOV
lea addresses_WT+0x1fe93, %rsi
lea addresses_WC+0x15513, %rdi
cmp %r10, %r10
mov $4, %rcx
rep movsb
nop
xor $38828, %rdi
// Store
lea addresses_RW+0x19693, %r10
nop
xor %r13, %r13
movw $0x5152, (%r10)
sub %r9, %r9
// Store
mov $0xc93, %r10
nop
add $51598, %rsi
mov $0x5152535455565758, %r13
movq %r13, (%r10)
nop
nop
nop
nop
xor $26773, %r13
// Store
mov $0xb73, %r10
nop
nop
nop
nop
add $44083, %r9
movw $0x5152, (%r10)
nop
nop
nop
nop
sub $45924, %rcx
// Faulty Load
lea addresses_normal+0xf293, %rsi
nop
nop
nop
nop
add %r9, %r9
movb (%rsi), %r13b
lea oracles, %rsi
and $0xff, %r13
shlq $12, %r13
mov (%rsi,%r13,1), %r13
pop %rsi
pop %rdi
pop %rcx
pop %r9
pop %r8
pop %r13
pop %r10
ret
/*
<gen_faulty_load>
[REF]
{'src': {'type': 'addresses_normal', 'AVXalign': False, 'size': 8, 'NT': False, 'same': False, 'congruent': 0}, 'OP': 'LOAD'}
{'src': {'type': 'addresses_WT', 'congruent': 9, 'same': False}, 'OP': 'REPM', 'dst': {'type': 'addresses_WC', 'congruent': 6, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_RW', 'AVXalign': False, 'size': 2, 'NT': False, 'same': False, 'congruent': 9}}
{'OP': 'STOR', 'dst': {'type': 'addresses_P', 'AVXalign': False, 'size': 8, 'NT': False, 'same': False, 'congruent': 9}}
{'OP': 'STOR', 'dst': {'type': 'addresses_P', 'AVXalign': False, 'size': 2, 'NT': False, 'same': False, 'congruent': 5}}
[Faulty Load]
{'src': {'type': 'addresses_normal', 'AVXalign': False, 'size': 1, 'NT': False, 'same': True, 'congruent': 0}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'src': {'type': 'addresses_A_ht', 'AVXalign': False, 'size': 16, 'NT': False, 'same': False, 'congruent': 10}, 'OP': 'LOAD'}
{'OP': 'STOR', 'dst': {'type': 'addresses_WC_ht', 'AVXalign': False, 'size': 2, 'NT': False, 'same': False, 'congruent': 5}}
{'src': {'type': 'addresses_WT_ht', 'congruent': 6, 'same': False}, 'OP': 'REPM', 'dst': {'type': 'addresses_WT_ht', 'congruent': 2, 'same': False}}
{'src': {'type': 'addresses_WT_ht', 'congruent': 11, 'same': False}, 'OP': 'REPM', 'dst': {'type': 'addresses_A_ht', 'congruent': 1, 'same': False}}
{'34': 21829}
34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34
*/
|
#include "Cylinder.h"
#include "Vec2U.h"
#include "Vec3U.h"
START_CB
bool Cylinder::IsValid() const
{
ASSERT( m_base.IsValid() );
ASSERT( m_radius > 0.f );
ASSERT( m_height > 0.f );
return true;
}
bool Cylinder::Contains(const Vec3 & point) const
{
// see also gPointInCylinder
if ( point.z < GetLoZ() || point.z > GetHiZ() )
return false;
float dXYSqr = DistanceSqrXY(point,m_base);
return ( dXYSqr < fsquare(m_radius) );
}
void Cylinder::ClampInside(Vec3 * pTo, const Vec3 & p) const
{
pTo->z = fclamp( p.z, GetLoZ(), GetHiZ() );
float dXYSqr = DistanceSqrXY(p,m_base);
if ( dXYSqr < fsquare(m_radius) )
{
pTo->x = p.x;
pTo->y = p.y;
}
else
{
// clamp to base
Vec2 d = MakeProjectionXY(p) - MakeProjectionXY(m_base);
d *= m_radius / sqrtf(dXYSqr);
pTo->x = m_base.x + d.x;
pTo->y = m_base.y + d.y;
}
}
float Cylinder::GetDistanceSqr(const Vec3 & point) const
{
Vec3 inside;
ClampInside(&inside,point);
return DistanceSqr(inside,point);
}
void Cylinder::ScaleFromCenter(const float s)
{
const Vec3 center = GetCenter();
m_height *= s;
m_radius *= s;
m_base = center;
m_base.z -= m_height * 0.5f;
}
/*static*/ bool Cylinder::Equals(const Cylinder &a,const Cylinder &b,const float tolerance)
{
return Vec3::Equals(a.m_base,b.m_base,tolerance) &&
fequal(a.m_height,b.m_height,tolerance) &&
fequal(a.m_radius,b.m_radius,tolerance);
}
END_CB
|
; A157240: a(n) = A128018(n) + 1.
; 2,-1,-7,-7,17,65,65,-127,-511,-511,1025,4097,4097,-8191,-32767,-32767,65537,262145,262145,-524287,-2097151,-2097151,4194305,16777217,16777217,-33554431,-134217727,-134217727,268435457,1073741825,1073741825,-2147483647,-8589934591,-8589934591,17179869185,68719476737,68719476737,-137438953471,-549755813887,-549755813887,1099511627777,4398046511105,4398046511105,-8796093022207,-35184372088831,-35184372088831,70368744177665,281474976710657,281474976710657,-562949953421311,-2251799813685247,-2251799813685247,4503599627370497
add $0,1
mov $1,2
mov $2,1
lpb $0
sub $0,1
mul $1,2
mul $2,2
sub $2,$1
add $1,$2
lpe
sub $1,2
div $1,6
mul $1,3
add $1,2
|
; half_t __fma (half_t left, half_t middle, half_t right)
SECTION code_fp_math16
PUBLIC cm16_sccz80_fma
EXTERN asm_f24_f16
EXTERN asm_f16_f24
EXTERN asm_f24_mul_f24
EXTERN asm_f24_add_f24
.cm16_sccz80_fma
; fma three sccz80 halfs
;
; enter : stack = sccz80_half left, sccz80_half middle, sccz80_half right, ret
;
; exit : HL = sccz80_half(left*middle+right)
;
; uses : af, bc, de, hl, af', bc', de', hl'
pop bc ; pop return address
pop de ; get right operand off of the stack
pop hl ; get middle operand off the stack
exx
pop hl ; get left operand off of the stack
push hl
call asm_f24_f16 ; expand left to dehl
exx
push hl
push de
push bc ; return address on stack
push de ; save right operand to add later
call asm_f24_f16 ; expand middle to dehl
call asm_f24_mul_f24
exx
pop hl ; get right operand off the stack
call asm_f24_f16 ; expand right to dehl
call asm_f24_add_f24
jp asm_f16_f24 ; return HL = sccz80_half
|
;------------------------------------------------------------------------------
;
; Copyright (c) 2006, Intel Corporation. All rights reserved.<BR>
; This program and the accompanying materials
; are licensed and made available under the terms and conditions of the BSD License
; which accompanies this distribution. The full text of the license may be found at
; http://opensource.org/licenses/bsd-license.php.
;
; THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
; WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
;
; Module Name:
;
; SetMem16.asm
;
; Abstract:
;
; SetMem16 function
;
; Notes:
;
;------------------------------------------------------------------------------
.686
.model flat,C
.mmx
.code
;------------------------------------------------------------------------------
; VOID *
; EFIAPI
; InternalMemSetMem16 (
; IN VOID *Buffer,
; IN UINTN Count,
; IN UINT16 Value
; )
;------------------------------------------------------------------------------
InternalMemSetMem16 PROC USES edi
mov eax, [esp + 16]
shrd edx, eax, 16
shld eax, edx, 16
mov edx, [esp + 12]
mov edi, [esp + 8]
mov ecx, edx
and edx, 3
shr ecx, 2
jz @SetWords
movd mm0, eax
movd mm1, eax
psllq mm0, 32
por mm0, mm1
@@:
movq [edi], mm0
add edi, 8
loop @B
@SetWords:
mov ecx, edx
rep stosw
mov eax, [esp + 8]
ret
InternalMemSetMem16 ENDP
END
|
typedef struct instancing_uniforms
{
mat4 mvp_mat;
vec4 v_color;
} instancing_uniforms;
void instancing_vs(float* vs_output, void* vertex_attribs, Shader_Builtins* builtins, void* uniforms);
void instancing_fs(float* fs_input, Shader_Builtins* builtins, void* uniforms);
void test_instancing(int argc, char** argv, void* data)
{
srand(0);
float points[] = { -0.05, -0.05, 0,
0.05, -0.05, 0,
0, 0.05, 0 };
vec2 positions[100];
int i = 0;
float offset = 0.1f;
for (int y = -10; y < 10; y += 2)
{
for (int x = -10; x < 10; x += 2)
{
vec2 pos;
pos.x = (float)x / 10.0f + offset;
pos.y = (float)y / 10.0f + offset;
positions[i++] = pos;
}
}
vec3 inst_colors[10];
for (int i=0; i<10; i++) {
inst_colors[i] = make_vec3(rsw_randf(), rsw_randf(), rsw_randf());
}
GLuint instance_pos;
glGenBuffers(1, &instance_pos);
glBindBuffer(GL_ARRAY_BUFFER, instance_pos);
glBufferData(GL_ARRAY_BUFFER, sizeof(vec2) * 100, &positions[0], GL_STATIC_DRAW);
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(vec2), 0);
glVertexAttribDivisor(1, 1);
GLuint instance_colors;
glGenBuffers(1, &instance_colors);
glBindBuffer(GL_ARRAY_BUFFER, instance_colors);
glBufferData(GL_ARRAY_BUFFER, sizeof(vec3) * 10, &inst_colors[0], GL_STATIC_DRAW);
glEnableVertexAttribArray(2);
glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, sizeof(vec3), 0);
glVertexAttribDivisor(2, 10);
instancing_uniforms the_uniforms;
mat4 identity = IDENTITY_MAT4();
GLuint triangle;
glGenBuffers(1, &triangle);
glBindBuffer(GL_ARRAY_BUFFER, triangle);
glBufferData(GL_ARRAY_BUFFER, sizeof(points), points, GL_STATIC_DRAW);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
GLenum flat[3] = { FLAT, FLAT, FLAT };
GLuint myshader = pglCreateProgram(instancing_vs, instancing_fs, 3, flat, GL_FALSE);
glUseProgram(myshader);
pglSetUniform(&the_uniforms);
memcpy(the_uniforms.mvp_mat, identity, sizeof(mat4));
glClearColor(0, 0, 0, 1);
glClear(GL_COLOR_BUFFER_BIT);
glDrawArraysInstanced(GL_TRIANGLES, 0, 3, 100);
}
void instancing_vs(float* vs_output, void* vertex_attribs, Shader_Builtins* builtins, void* uniforms)
{
vec4 vert = ((vec4*)vertex_attribs)[0];
vec4 offset = ((vec4*)vertex_attribs)[1];
vert.x += offset.x;
vert.y += offset.y;
vec4 color = ((vec4*)vertex_attribs)[2];
*(vec3*)vs_output = make_vec3(color.x, color.y, color.z);
// 0 and 1 are default for z and w
builtins->gl_Position = vert;
}
void instancing_fs(float* fs_input, Shader_Builtins* builtins, void* uniforms)
{
builtins->gl_FragColor = make_vec4(fs_input[0], fs_input[1], fs_input[2], 1);
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.