Copy+Attentional Convolutional

Original Name get,node

get

<SENTENCE_START> { long c ptr = collision jni . bt dbvt s stk np node get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt dbvt node ( c ptr , false ) ; } <SENTENCE_END/>

(Copy Probability: 3.0%)

<SENTENCE_START> { long c ptr = collision jni . bt dbvt s stk np node get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt dbvt node ( c ptr , false ) ; } <SENTENCE_END/>

node

<SENTENCE_START> { long c ptr = collision jni . bt dbvt s stk np node get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt dbvt node ( c ptr , false ) ; } <SENTENCE_END/>

(Copy Probability: 99.5%)

<SENTENCE_START> { long c ptr = collision jni . bt dbvt s stk np node get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt dbvt node ( c ptr , false ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { long c ptr = collision jni . bt dbvt s stk np node get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt dbvt node ( c ptr , false ) ; } <SENTENCE_END/>

(Copy Probability: 2.6%)

<SENTENCE_START> { long c ptr = collision jni . bt dbvt s stk np node get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt dbvt node ( c ptr , false ) ; } <SENTENCE_END/>

Original Name set,mask

set

<SENTENCE_START> { collision jni . bt dbvt s stk np mask set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 2.0%)

<SENTENCE_START> { collision jni . bt dbvt s stk np mask set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

mask

<SENTENCE_START> { collision jni . bt dbvt s stk np mask set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 98.2%)

<SENTENCE_START> { collision jni . bt dbvt s stk np mask set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { collision jni . bt dbvt s stk np mask set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 0.7%)

<SENTENCE_START> { collision jni . bt dbvt s stk np mask set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

Original Name get,mask

get

<SENTENCE_START> { return collision jni . bt dbvt s stk np mask get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 1.9%)

<SENTENCE_START> { return collision jni . bt dbvt s stk np mask get ( swig c ptr , this ) ; } <SENTENCE_END/>

mask

<SENTENCE_START> { return collision jni . bt dbvt s stk np mask get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 97.8%)

<SENTENCE_START> { return collision jni . bt dbvt s stk np mask get ( swig c ptr , this ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return collision jni . bt dbvt s stk np mask get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 1.0%)

<SENTENCE_START> { return collision jni . bt dbvt s stk np mask get ( swig c ptr , this ) ; } <SENTENCE_END/>

Original Name get,c,ptr

get

<SENTENCE_START> { return ( obj == null ) ? 0 : obj . swig c ptr ; } <SENTENCE_END/>

(Copy Probability: 1.5%)

<SENTENCE_START> { return ( obj == null ) ? 0 : obj . swig c ptr ; } <SENTENCE_END/>

c

<SENTENCE_START> { return ( obj == null ) ? 0 : obj . swig c ptr ; } <SENTENCE_END/>

(Copy Probability: 99.7%)

<SENTENCE_START> { return ( obj == null ) ? 0 : obj . swig c ptr ; } <SENTENCE_END/>

ptr

<SENTENCE_START> { return ( obj == null ) ? 0 : obj . swig c ptr ; } <SENTENCE_END/>

(Copy Probability: 99.8%)

<SENTENCE_START> { return ( obj == null ) ? 0 : obj . swig c ptr ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return ( obj == null ) ? 0 : obj . swig c ptr ; } <SENTENCE_END/>

(Copy Probability: 3.7%)

<SENTENCE_START> { return ( obj == null ) ? 0 : obj . swig c ptr ; } <SENTENCE_END/>

Original Name set,node

set

<SENTENCE_START> { collision jni . bt dbvt s stk nps node set ( swig c ptr , this , bt dbvt node . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

(Copy Probability: 2.8%)

<SENTENCE_START> { collision jni . bt dbvt s stk nps node set ( swig c ptr , this , bt dbvt node . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

node

<SENTENCE_START> { collision jni . bt dbvt s stk nps node set ( swig c ptr , this , bt dbvt node . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

(Copy Probability: 99.4%)

<SENTENCE_START> { collision jni . bt dbvt s stk nps node set ( swig c ptr , this , bt dbvt node . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { collision jni . bt dbvt s stk nps node set ( swig c ptr , this , bt dbvt node . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

(Copy Probability: 2.0%)

<SENTENCE_START> { collision jni . bt dbvt s stk nps node set ( swig c ptr , this , bt dbvt node . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

Original Name get,node

get

<SENTENCE_START> { long c ptr = collision jni . bt dbvt s stk nps node get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt dbvt node ( c ptr , false ) ; } <SENTENCE_END/>

(Copy Probability: 3.0%)

<SENTENCE_START> { long c ptr = collision jni . bt dbvt s stk nps node get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt dbvt node ( c ptr , false ) ; } <SENTENCE_END/>

node

<SENTENCE_START> { long c ptr = collision jni . bt dbvt s stk nps node get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt dbvt node ( c ptr , false ) ; } <SENTENCE_END/>

(Copy Probability: 99.5%)

<SENTENCE_START> { long c ptr = collision jni . bt dbvt s stk nps node get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt dbvt node ( c ptr , false ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { long c ptr = collision jni . bt dbvt s stk nps node get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt dbvt node ( c ptr , false ) ; } <SENTENCE_END/>

(Copy Probability: 2.6%)

<SENTENCE_START> { long c ptr = collision jni . bt dbvt s stk nps node get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt dbvt node ( c ptr , false ) ; } <SENTENCE_END/>

Original Name set,mask

set

<SENTENCE_START> { collision jni . bt dbvt s stk nps mask set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 2.0%)

<SENTENCE_START> { collision jni . bt dbvt s stk nps mask set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

mask

<SENTENCE_START> { collision jni . bt dbvt s stk nps mask set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 98.2%)

<SENTENCE_START> { collision jni . bt dbvt s stk nps mask set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { collision jni . bt dbvt s stk nps mask set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 0.7%)

<SENTENCE_START> { collision jni . bt dbvt s stk nps mask set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

Original Name get,mask

get

<SENTENCE_START> { return collision jni . bt dbvt s stk nps mask get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 1.9%)

<SENTENCE_START> { return collision jni . bt dbvt s stk nps mask get ( swig c ptr , this ) ; } <SENTENCE_END/>

mask

<SENTENCE_START> { return collision jni . bt dbvt s stk nps mask get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 97.8%)

<SENTENCE_START> { return collision jni . bt dbvt s stk nps mask get ( swig c ptr , this ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return collision jni . bt dbvt s stk nps mask get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 1.0%)

<SENTENCE_START> { return collision jni . bt dbvt s stk nps mask get ( swig c ptr , this ) ; } <SENTENCE_END/>

Original Name set,value

set

<SENTENCE_START> { collision jni . bt dbvt s stk nps value set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 1.5%)

<SENTENCE_START> { collision jni . bt dbvt s stk nps value set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

value

<SENTENCE_START> { collision jni . bt dbvt s stk nps value set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 97.8%)

<SENTENCE_START> { collision jni . bt dbvt s stk nps value set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { collision jni . bt dbvt s stk nps value set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 0.7%)

<SENTENCE_START> { collision jni . bt dbvt s stk nps value set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

Original Name get,value

get

<SENTENCE_START> { return collision jni . bt dbvt s stk nps value get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 1.3%)

<SENTENCE_START> { return collision jni . bt dbvt s stk nps value get ( swig c ptr , this ) ; } <SENTENCE_END/>

value

<SENTENCE_START> { return collision jni . bt dbvt s stk nps value get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 96.9%)

<SENTENCE_START> { return collision jni . bt dbvt s stk nps value get ( swig c ptr , this ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return collision jni . bt dbvt s stk nps value get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 0.7%)

<SENTENCE_START> { return collision jni . bt dbvt s stk nps value get ( swig c ptr , this ) ; } <SENTENCE_END/>

Original Name get,c,ptr

get

<SENTENCE_START> { return ( obj == null ) ? 0 : obj . swig c ptr ; } <SENTENCE_END/>

(Copy Probability: 1.5%)

<SENTENCE_START> { return ( obj == null ) ? 0 : obj . swig c ptr ; } <SENTENCE_END/>

c

<SENTENCE_START> { return ( obj == null ) ? 0 : obj . swig c ptr ; } <SENTENCE_END/>

(Copy Probability: 99.7%)

<SENTENCE_START> { return ( obj == null ) ? 0 : obj . swig c ptr ; } <SENTENCE_END/>

ptr

<SENTENCE_START> { return ( obj == null ) ? 0 : obj . swig c ptr ; } <SENTENCE_END/>

(Copy Probability: 99.8%)

<SENTENCE_START> { return ( obj == null ) ? 0 : obj . swig c ptr ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return ( obj == null ) ? 0 : obj . swig c ptr ; } <SENTENCE_END/>

(Copy Probability: 3.7%)

<SENTENCE_START> { return ( obj == null ) ? 0 : obj . swig c ptr ; } <SENTENCE_END/>

Original Name set,node

set

<SENTENCE_START> { collision jni . bt dbvt s stk cln node set ( swig c ptr , this , bt dbvt node . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

(Copy Probability: 2.8%)

<SENTENCE_START> { collision jni . bt dbvt s stk cln node set ( swig c ptr , this , bt dbvt node . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

node

<SENTENCE_START> { collision jni . bt dbvt s stk cln node set ( swig c ptr , this , bt dbvt node . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

(Copy Probability: 99.4%)

<SENTENCE_START> { collision jni . bt dbvt s stk cln node set ( swig c ptr , this , bt dbvt node . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { collision jni . bt dbvt s stk cln node set ( swig c ptr , this , bt dbvt node . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

(Copy Probability: 2.0%)

<SENTENCE_START> { collision jni . bt dbvt s stk cln node set ( swig c ptr , this , bt dbvt node . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

Original Name get,node

get

<SENTENCE_START> { long c ptr = collision jni . bt dbvt s stk cln node get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt dbvt node ( c ptr , false ) ; } <SENTENCE_END/>

(Copy Probability: 3.0%)

<SENTENCE_START> { long c ptr = collision jni . bt dbvt s stk cln node get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt dbvt node ( c ptr , false ) ; } <SENTENCE_END/>

node

<SENTENCE_START> { long c ptr = collision jni . bt dbvt s stk cln node get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt dbvt node ( c ptr , false ) ; } <SENTENCE_END/>

(Copy Probability: 99.5%)

<SENTENCE_START> { long c ptr = collision jni . bt dbvt s stk cln node get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt dbvt node ( c ptr , false ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { long c ptr = collision jni . bt dbvt s stk cln node get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt dbvt node ( c ptr , false ) ; } <SENTENCE_END/>

(Copy Probability: 2.6%)

<SENTENCE_START> { long c ptr = collision jni . bt dbvt s stk cln node get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt dbvt node ( c ptr , false ) ; } <SENTENCE_END/>

Original Name set,parent

set

<SENTENCE_START> { collision jni . bt dbvt s stk cln parent set ( swig c ptr , this , bt dbvt node . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

(Copy Probability: 3.0%)

<SENTENCE_START> { collision jni . bt dbvt s stk cln parent set ( swig c ptr , this , bt dbvt node . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

parent

<SENTENCE_START> { collision jni . bt dbvt s stk cln parent set ( swig c ptr , this , bt dbvt node . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

(Copy Probability: 99.3%)

<SENTENCE_START> { collision jni . bt dbvt s stk cln parent set ( swig c ptr , this , bt dbvt node . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { collision jni . bt dbvt s stk cln parent set ( swig c ptr , this , bt dbvt node . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

(Copy Probability: 3.8%)

<SENTENCE_START> { collision jni . bt dbvt s stk cln parent set ( swig c ptr , this , bt dbvt node . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

Original Name get,parent

get

<SENTENCE_START> { long c ptr = collision jni . bt dbvt s stk cln parent get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt dbvt node ( c ptr , false ) ; } <SENTENCE_END/>

(Copy Probability: 3.1%)

<SENTENCE_START> { long c ptr = collision jni . bt dbvt s stk cln parent get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt dbvt node ( c ptr , false ) ; } <SENTENCE_END/>

parent

<SENTENCE_START> { long c ptr = collision jni . bt dbvt s stk cln parent get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt dbvt node ( c ptr , false ) ; } <SENTENCE_END/>

(Copy Probability: 99.5%)

<SENTENCE_START> { long c ptr = collision jni . bt dbvt s stk cln parent get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt dbvt node ( c ptr , false ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { long c ptr = collision jni . bt dbvt s stk cln parent get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt dbvt node ( c ptr , false ) ; } <SENTENCE_END/>

(Copy Probability: 3.7%)

<SENTENCE_START> { long c ptr = collision jni . bt dbvt s stk cln parent get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt dbvt node ( c ptr , false ) ; } <SENTENCE_END/>

Original Name get,c,ptr

get

<SENTENCE_START> { return ( obj == null ) ? 0 : obj . swig c ptr ; } <SENTENCE_END/>

(Copy Probability: 1.5%)

<SENTENCE_START> { return ( obj == null ) ? 0 : obj . swig c ptr ; } <SENTENCE_END/>

c

<SENTENCE_START> { return ( obj == null ) ? 0 : obj . swig c ptr ; } <SENTENCE_END/>

(Copy Probability: 99.7%)

<SENTENCE_START> { return ( obj == null ) ? 0 : obj . swig c ptr ; } <SENTENCE_END/>

ptr

<SENTENCE_START> { return ( obj == null ) ? 0 : obj . swig c ptr ; } <SENTENCE_END/>

(Copy Probability: 99.8%)

<SENTENCE_START> { return ( obj == null ) ? 0 : obj . swig c ptr ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return ( obj == null ) ? 0 : obj . swig c ptr ; } <SENTENCE_END/>

(Copy Probability: 3.7%)

<SENTENCE_START> { return ( obj == null ) ? 0 : obj . swig c ptr ; } <SENTENCE_END/>

Original Name prepare

prepare

<SENTENCE_START> { collision jni . bt dbvt i writer prepare ( swig c ptr , this , bt dbvt node . get c ptr ( root ) , root , numnodes ) ; } <SENTENCE_END/>

(Copy Probability: 15.9%)

<SENTENCE_START> { collision jni . bt dbvt i writer prepare ( swig c ptr , this , bt dbvt node . get c ptr ( root ) , root , numnodes ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { collision jni . bt dbvt i writer prepare ( swig c ptr , this , bt dbvt node . get c ptr ( root ) , root , numnodes ) ; } <SENTENCE_END/>

(Copy Probability: 39.2%)

<SENTENCE_START> { collision jni . bt dbvt i writer prepare ( swig c ptr , this , bt dbvt node . get c ptr ( root ) , root , numnodes ) ; } <SENTENCE_END/>

Original Name write,node

write

<SENTENCE_START> { collision jni . bt dbvt i writer write node ( swig c ptr , this , bt dbvt node . get c ptr ( arg 0 ) , arg 0 , index , parent , child 0 , child 1 ) ; } <SENTENCE_END/>

(Copy Probability: 10.3%)

<SENTENCE_START> { collision jni . bt dbvt i writer write node ( swig c ptr , this , bt dbvt node . get c ptr ( arg 0 ) , arg 0 , index , parent , child 0 , child 1 ) ; } <SENTENCE_END/>

node

<SENTENCE_START> { collision jni . bt dbvt i writer write node ( swig c ptr , this , bt dbvt node . get c ptr ( arg 0 ) , arg 0 , index , parent , child 0 , child 1 ) ; } <SENTENCE_END/>

(Copy Probability: 85.1%)

<SENTENCE_START> { collision jni . bt dbvt i writer write node ( swig c ptr , this , bt dbvt node . get c ptr ( arg 0 ) , arg 0 , index , parent , child 0 , child 1 ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { collision jni . bt dbvt i writer write node ( swig c ptr , this , bt dbvt node . get c ptr ( arg 0 ) , arg 0 , index , parent , child 0 , child 1 ) ; } <SENTENCE_END/>

(Copy Probability: 3.9%)

<SENTENCE_START> { collision jni . bt dbvt i writer write node ( swig c ptr , this , bt dbvt node . get c ptr ( arg 0 ) , arg 0 , index , parent , child 0 , child 1 ) ; } <SENTENCE_END/>

Original Name write,leaf

write

<SENTENCE_START> { collision jni . bt dbvt i writer write leaf ( swig c ptr , this , bt dbvt node . get c ptr ( arg 0 ) , arg 0 , index , parent ) ; } <SENTENCE_END/>

(Copy Probability: 21.5%)

<SENTENCE_START> { collision jni . bt dbvt i writer write leaf ( swig c ptr , this , bt dbvt node . get c ptr ( arg 0 ) , arg 0 , index , parent ) ; } <SENTENCE_END/>

leaf

<SENTENCE_START> { collision jni . bt dbvt i writer write leaf ( swig c ptr , this , bt dbvt node . get c ptr ( arg 0 ) , arg 0 , index , parent ) ; } <SENTENCE_END/>

(Copy Probability: 99.1%)

<SENTENCE_START> { collision jni . bt dbvt i writer write leaf ( swig c ptr , this , bt dbvt node . get c ptr ( arg 0 ) , arg 0 , index , parent ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { collision jni . bt dbvt i writer write leaf ( swig c ptr , this , bt dbvt node . get c ptr ( arg 0 ) , arg 0 , index , parent ) ; } <SENTENCE_END/>

(Copy Probability: 3.0%)

<SENTENCE_START> { collision jni . bt dbvt i writer write leaf ( swig c ptr , this , bt dbvt node . get c ptr ( arg 0 ) , arg 0 , index , parent ) ; } <SENTENCE_END/>

Original Name get,c,ptr

get

<SENTENCE_START> { return ( obj == null ) ? 0 : obj . swig c ptr ; } <SENTENCE_END/>

(Copy Probability: 1.5%)

<SENTENCE_START> { return ( obj == null ) ? 0 : obj . swig c ptr ; } <SENTENCE_END/>

c

<SENTENCE_START> { return ( obj == null ) ? 0 : obj . swig c ptr ; } <SENTENCE_END/>

(Copy Probability: 99.7%)

<SENTENCE_START> { return ( obj == null ) ? 0 : obj . swig c ptr ; } <SENTENCE_END/>

ptr

<SENTENCE_START> { return ( obj == null ) ? 0 : obj . swig c ptr ; } <SENTENCE_END/>

(Copy Probability: 99.8%)

<SENTENCE_START> { return ( obj == null ) ? 0 : obj . swig c ptr ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return ( obj == null ) ? 0 : obj . swig c ptr ; } <SENTENCE_END/>

(Copy Probability: 3.7%)

<SENTENCE_START> { return ( obj == null ) ? 0 : obj . swig c ptr ; } <SENTENCE_END/>

Original Name clone,leaf

clone

<SENTENCE_START> { collision jni . bt dbvt i clone clone leaf ( swig c ptr , this , bt dbvt node . get c ptr ( arg 0 ) , arg 0 ) ; } <SENTENCE_END/>

(Copy Probability: 22.6%)

<SENTENCE_START> { collision jni . bt dbvt i clone clone leaf ( swig c ptr , this , bt dbvt node . get c ptr ( arg 0 ) , arg 0 ) ; } <SENTENCE_END/>

leaf

<SENTENCE_START> { collision jni . bt dbvt i clone clone leaf ( swig c ptr , this , bt dbvt node . get c ptr ( arg 0 ) , arg 0 ) ; } <SENTENCE_END/>

(Copy Probability: 99.3%)

<SENTENCE_START> { collision jni . bt dbvt i clone clone leaf ( swig c ptr , this , bt dbvt node . get c ptr ( arg 0 ) , arg 0 ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { collision jni . bt dbvt i clone clone leaf ( swig c ptr , this , bt dbvt node . get c ptr ( arg 0 ) , arg 0 ) ; } <SENTENCE_END/>

(Copy Probability: 2.5%)

<SENTENCE_START> { collision jni . bt dbvt i clone clone leaf ( swig c ptr , this , bt dbvt node . get c ptr ( arg 0 ) , arg 0 ) ; } <SENTENCE_END/>

Original Name set,root

set

<SENTENCE_START> { collision jni . bt dbvt root set ( swig c ptr , this , bt dbvt node . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

(Copy Probability: 2.2%)

<SENTENCE_START> { collision jni . bt dbvt root set ( swig c ptr , this , bt dbvt node . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

root

<SENTENCE_START> { collision jni . bt dbvt root set ( swig c ptr , this , bt dbvt node . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

(Copy Probability: 96.6%)

<SENTENCE_START> { collision jni . bt dbvt root set ( swig c ptr , this , bt dbvt node . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { collision jni . bt dbvt root set ( swig c ptr , this , bt dbvt node . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

(Copy Probability: 2.2%)

<SENTENCE_START> { collision jni . bt dbvt root set ( swig c ptr , this , bt dbvt node . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

Original Name get,root

get

<SENTENCE_START> { long c ptr = collision jni . bt dbvt root get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt dbvt node ( c ptr , false ) ; } <SENTENCE_END/>

(Copy Probability: 2.2%)

<SENTENCE_START> { long c ptr = collision jni . bt dbvt root get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt dbvt node ( c ptr , false ) ; } <SENTENCE_END/>

root

<SENTENCE_START> { long c ptr = collision jni . bt dbvt root get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt dbvt node ( c ptr , false ) ; } <SENTENCE_END/>

(Copy Probability: 97.0%)

<SENTENCE_START> { long c ptr = collision jni . bt dbvt root get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt dbvt node ( c ptr , false ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { long c ptr = collision jni . bt dbvt root get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt dbvt node ( c ptr , false ) ; } <SENTENCE_END/>

(Copy Probability: 1.9%)

<SENTENCE_START> { long c ptr = collision jni . bt dbvt root get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt dbvt node ( c ptr , false ) ; } <SENTENCE_END/>

Original Name set,free

set

<SENTENCE_START> { collision jni . bt dbvt free set ( swig c ptr , this , bt dbvt node . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

(Copy Probability: 1.9%)

<SENTENCE_START> { collision jni . bt dbvt free set ( swig c ptr , this , bt dbvt node . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

free

<SENTENCE_START> { collision jni . bt dbvt free set ( swig c ptr , this , bt dbvt node . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

(Copy Probability: 94.8%)

<SENTENCE_START> { collision jni . bt dbvt free set ( swig c ptr , this , bt dbvt node . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { collision jni . bt dbvt free set ( swig c ptr , this , bt dbvt node . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

(Copy Probability: 2.1%)

<SENTENCE_START> { collision jni . bt dbvt free set ( swig c ptr , this , bt dbvt node . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

Original Name get,free

get

<SENTENCE_START> { long c ptr = collision jni . bt dbvt free get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt dbvt node ( c ptr , false ) ; } <SENTENCE_END/>

(Copy Probability: 2.0%)

<SENTENCE_START> { long c ptr = collision jni . bt dbvt free get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt dbvt node ( c ptr , false ) ; } <SENTENCE_END/>

free

<SENTENCE_START> { long c ptr = collision jni . bt dbvt free get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt dbvt node ( c ptr , false ) ; } <SENTENCE_END/>

(Copy Probability: 95.3%)

<SENTENCE_START> { long c ptr = collision jni . bt dbvt free get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt dbvt node ( c ptr , false ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { long c ptr = collision jni . bt dbvt free get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt dbvt node ( c ptr , false ) ; } <SENTENCE_END/>

(Copy Probability: 1.9%)

<SENTENCE_START> { long c ptr = collision jni . bt dbvt free get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt dbvt node ( c ptr , false ) ; } <SENTENCE_END/>

Original Name set,lkhd

set

<SENTENCE_START> { collision jni . bt dbvt lkhd set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 1.3%)

<SENTENCE_START> { collision jni . bt dbvt lkhd set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

lkhd

<SENTENCE_START> { collision jni . bt dbvt lkhd set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 77.3%)

<SENTENCE_START> { collision jni . bt dbvt lkhd set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { collision jni . bt dbvt lkhd set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 0.7%)

<SENTENCE_START> { collision jni . bt dbvt lkhd set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

Original Name get,lkhd

get

<SENTENCE_START> { return collision jni . bt dbvt lkhd get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 1.2%)

<SENTENCE_START> { return collision jni . bt dbvt lkhd get ( swig c ptr , this ) ; } <SENTENCE_END/>

lkhd

<SENTENCE_START> { return collision jni . bt dbvt lkhd get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 78.0%)

<SENTENCE_START> { return collision jni . bt dbvt lkhd get ( swig c ptr , this ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return collision jni . bt dbvt lkhd get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 1.1%)

<SENTENCE_START> { return collision jni . bt dbvt lkhd get ( swig c ptr , this ) ; } <SENTENCE_END/>

Original Name set,leaves

set

<SENTENCE_START> { collision jni . bt dbvt leaves set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 1.3%)

<SENTENCE_START> { collision jni . bt dbvt leaves set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

leaves

<SENTENCE_START> { collision jni . bt dbvt leaves set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 77.3%)

<SENTENCE_START> { collision jni . bt dbvt leaves set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { collision jni . bt dbvt leaves set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 0.7%)

<SENTENCE_START> { collision jni . bt dbvt leaves set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

Original Name get,leaves

get

<SENTENCE_START> { return collision jni . bt dbvt leaves get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 1.2%)

<SENTENCE_START> { return collision jni . bt dbvt leaves get ( swig c ptr , this ) ; } <SENTENCE_END/>

leaves

<SENTENCE_START> { return collision jni . bt dbvt leaves get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 78.0%)

<SENTENCE_START> { return collision jni . bt dbvt leaves get ( swig c ptr , this ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return collision jni . bt dbvt leaves get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 1.1%)

<SENTENCE_START> { return collision jni . bt dbvt leaves get ( swig c ptr , this ) ; } <SENTENCE_END/>

Original Name set,opath

set

<SENTENCE_START> { collision jni . bt dbvt opath set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 1.3%)

<SENTENCE_START> { collision jni . bt dbvt opath set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

opath

<SENTENCE_START> { collision jni . bt dbvt opath set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 77.3%)

<SENTENCE_START> { collision jni . bt dbvt opath set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { collision jni . bt dbvt opath set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 0.7%)

<SENTENCE_START> { collision jni . bt dbvt opath set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

Original Name get,opath

get

<SENTENCE_START> { return collision jni . bt dbvt opath get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 1.2%)

<SENTENCE_START> { return collision jni . bt dbvt opath get ( swig c ptr , this ) ; } <SENTENCE_END/>

opath

<SENTENCE_START> { return collision jni . bt dbvt opath get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 78.0%)

<SENTENCE_START> { return collision jni . bt dbvt opath get ( swig c ptr , this ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return collision jni . bt dbvt opath get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 1.1%)

<SENTENCE_START> { return collision jni . bt dbvt opath get ( swig c ptr , this ) ; } <SENTENCE_END/>

Original Name set,stk,stack

set

<SENTENCE_START> { collision jni . bt dbvt stk stack set ( swig c ptr , this , swigtype p bt aligned object array t bt dbvt s stk nn t . get c ptr ( value ) ) ; } <SENTENCE_END/>

(Copy Probability: 2.8%)

<SENTENCE_START> { collision jni . bt dbvt stk stack set ( swig c ptr , this , swigtype p bt aligned object array t bt dbvt s stk nn t . get c ptr ( value ) ) ; } <SENTENCE_END/>

stk

<SENTENCE_START> { collision jni . bt dbvt stk stack set ( swig c ptr , this , swigtype p bt aligned object array t bt dbvt s stk nn t . get c ptr ( value ) ) ; } <SENTENCE_END/>

(Copy Probability: 92.9%)

<SENTENCE_START> { collision jni . bt dbvt stk stack set ( swig c ptr , this , swigtype p bt aligned object array t bt dbvt s stk nn t . get c ptr ( value ) ) ; } <SENTENCE_END/>

stack

<SENTENCE_START> { collision jni . bt dbvt stk stack set ( swig c ptr , this , swigtype p bt aligned object array t bt dbvt s stk nn t . get c ptr ( value ) ) ; } <SENTENCE_END/>

(Copy Probability: 2.7%)

<SENTENCE_START> { collision jni . bt dbvt stk stack set ( swig c ptr , this , swigtype p bt aligned object array t bt dbvt s stk nn t . get c ptr ( value ) ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { collision jni . bt dbvt stk stack set ( swig c ptr , this , swigtype p bt aligned object array t bt dbvt s stk nn t . get c ptr ( value ) ) ; } <SENTENCE_END/>

(Copy Probability: 2.5%)

<SENTENCE_START> { collision jni . bt dbvt stk stack set ( swig c ptr , this , swigtype p bt aligned object array t bt dbvt s stk nn t . get c ptr ( value ) ) ; } <SENTENCE_END/>

Original Name get,stk,stack

get

<SENTENCE_START> { long c ptr = collision jni . bt dbvt stk stack get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new swigtype p bt aligned object array t bt dbvt s stk nn t ( c ptr , false ) ; } <SENTENCE_END/>

(Copy Probability: 2.6%)

<SENTENCE_START> { long c ptr = collision jni . bt dbvt stk stack get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new swigtype p bt aligned object array t bt dbvt s stk nn t ( c ptr , false ) ; } <SENTENCE_END/>

stk

<SENTENCE_START> { long c ptr = collision jni . bt dbvt stk stack get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new swigtype p bt aligned object array t bt dbvt s stk nn t ( c ptr , false ) ; } <SENTENCE_END/>

(Copy Probability: 91.3%)

<SENTENCE_START> { long c ptr = collision jni . bt dbvt stk stack get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new swigtype p bt aligned object array t bt dbvt s stk nn t ( c ptr , false ) ; } <SENTENCE_END/>

stack

<SENTENCE_START> { long c ptr = collision jni . bt dbvt stk stack get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new swigtype p bt aligned object array t bt dbvt s stk nn t ( c ptr , false ) ; } <SENTENCE_END/>

(Copy Probability: 2.1%)

<SENTENCE_START> { long c ptr = collision jni . bt dbvt stk stack get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new swigtype p bt aligned object array t bt dbvt s stk nn t ( c ptr , false ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { long c ptr = collision jni . bt dbvt stk stack get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new swigtype p bt aligned object array t bt dbvt s stk nn t ( c ptr , false ) ; } <SENTENCE_END/>

(Copy Probability: 2.4%)

<SENTENCE_START> { long c ptr = collision jni . bt dbvt stk stack get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new swigtype p bt aligned object array t bt dbvt s stk nn t ( c ptr , false ) ; } <SENTENCE_END/>

Original Name set,ray,test,stack

set

<SENTENCE_START> { collision jni . bt dbvt ray test stack set ( swig c ptr , this , swigtype p bt aligned object array t bt dbvt node const p t . get c ptr ( value ) ) ; } <SENTENCE_END/>

(Copy Probability: 3.9%)

<SENTENCE_START> { collision jni . bt dbvt ray test stack set ( swig c ptr , this , swigtype p bt aligned object array t bt dbvt node const p t . get c ptr ( value ) ) ; } <SENTENCE_END/>

ray

<SENTENCE_START> { collision jni . bt dbvt ray test stack set ( swig c ptr , this , swigtype p bt aligned object array t bt dbvt node const p t . get c ptr ( value ) ) ; } <SENTENCE_END/>

(Copy Probability: 99.0%)

<SENTENCE_START> { collision jni . bt dbvt ray test stack set ( swig c ptr , this , swigtype p bt aligned object array t bt dbvt node const p t . get c ptr ( value ) ) ; } <SENTENCE_END/>

test

<SENTENCE_START> { collision jni . bt dbvt ray test stack set ( swig c ptr , this , swigtype p bt aligned object array t bt dbvt node const p t . get c ptr ( value ) ) ; } <SENTENCE_END/>

(Copy Probability: 2.9%)

<SENTENCE_START> { collision jni . bt dbvt ray test stack set ( swig c ptr , this , swigtype p bt aligned object array t bt dbvt node const p t . get c ptr ( value ) ) ; } <SENTENCE_END/>

stack

<SENTENCE_START> { collision jni . bt dbvt ray test stack set ( swig c ptr , this , swigtype p bt aligned object array t bt dbvt node const p t . get c ptr ( value ) ) ; } <SENTENCE_END/>

(Copy Probability: 2.3%)

<SENTENCE_START> { collision jni . bt dbvt ray test stack set ( swig c ptr , this , swigtype p bt aligned object array t bt dbvt node const p t . get c ptr ( value ) ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { collision jni . bt dbvt ray test stack set ( swig c ptr , this , swigtype p bt aligned object array t bt dbvt node const p t . get c ptr ( value ) ) ; } <SENTENCE_END/>

(Copy Probability: 3.8%)

<SENTENCE_START> { collision jni . bt dbvt ray test stack set ( swig c ptr , this , swigtype p bt aligned object array t bt dbvt node const p t . get c ptr ( value ) ) ; } <SENTENCE_END/>

Original Name get,ray,test,stack

get

<SENTENCE_START> { long c ptr = collision jni . bt dbvt ray test stack get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new swigtype p bt aligned object array t bt dbvt node const p t ( c ptr , false ) ; } <SENTENCE_END/>

(Copy Probability: 3.1%)

<SENTENCE_START> { long c ptr = collision jni . bt dbvt ray test stack get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new swigtype p bt aligned object array t bt dbvt node const p t ( c ptr , false ) ; } <SENTENCE_END/>

ray

<SENTENCE_START> { long c ptr = collision jni . bt dbvt ray test stack get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new swigtype p bt aligned object array t bt dbvt node const p t ( c ptr , false ) ; } <SENTENCE_END/>

(Copy Probability: 99.2%)

<SENTENCE_START> { long c ptr = collision jni . bt dbvt ray test stack get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new swigtype p bt aligned object array t bt dbvt node const p t ( c ptr , false ) ; } <SENTENCE_END/>

test

<SENTENCE_START> { long c ptr = collision jni . bt dbvt ray test stack get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new swigtype p bt aligned object array t bt dbvt node const p t ( c ptr , false ) ; } <SENTENCE_END/>

(Copy Probability: 3.2%)

<SENTENCE_START> { long c ptr = collision jni . bt dbvt ray test stack get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new swigtype p bt aligned object array t bt dbvt node const p t ( c ptr , false ) ; } <SENTENCE_END/>

stack

<SENTENCE_START> { long c ptr = collision jni . bt dbvt ray test stack get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new swigtype p bt aligned object array t bt dbvt node const p t ( c ptr , false ) ; } <SENTENCE_END/>

(Copy Probability: 2.5%)

<SENTENCE_START> { long c ptr = collision jni . bt dbvt ray test stack get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new swigtype p bt aligned object array t bt dbvt node const p t ( c ptr , false ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { long c ptr = collision jni . bt dbvt ray test stack get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new swigtype p bt aligned object array t bt dbvt node const p t ( c ptr , false ) ; } <SENTENCE_END/>

(Copy Probability: 3.6%)

<SENTENCE_START> { long c ptr = collision jni . bt dbvt ray test stack get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new swigtype p bt aligned object array t bt dbvt node const p t ( c ptr , false ) ; } <SENTENCE_END/>

Original Name clear

clear

<SENTENCE_START> { collision jni . bt dbvt clear ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 1.7%)

<SENTENCE_START> { collision jni . bt dbvt clear ( swig c ptr , this ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { collision jni . bt dbvt clear ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 5.4%)

<SENTENCE_START> { collision jni . bt dbvt clear ( swig c ptr , this ) ; } <SENTENCE_END/>

Original Name empty

empty

<SENTENCE_START> { return collision jni . bt dbvt empty ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 2.0%)

<SENTENCE_START> { return collision jni . bt dbvt empty ( swig c ptr , this ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return collision jni . bt dbvt empty ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 8.0%)

<SENTENCE_START> { return collision jni . bt dbvt empty ( swig c ptr , this ) ; } <SENTENCE_END/>

Original Name optimize,bottom,up

optimize

<SENTENCE_START> { collision jni . bt dbvt optimize bottom up ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 21.0%)

<SENTENCE_START> { collision jni . bt dbvt optimize bottom up ( swig c ptr , this ) ; } <SENTENCE_END/>

bottom

<SENTENCE_START> { collision jni . bt dbvt optimize bottom up ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 54.8%)

<SENTENCE_START> { collision jni . bt dbvt optimize bottom up ( swig c ptr , this ) ; } <SENTENCE_END/>

up

<SENTENCE_START> { collision jni . bt dbvt optimize bottom up ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 1.2%)

<SENTENCE_START> { collision jni . bt dbvt optimize bottom up ( swig c ptr , this ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { collision jni . bt dbvt optimize bottom up ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 2.9%)

<SENTENCE_START> { collision jni . bt dbvt optimize bottom up ( swig c ptr , this ) ; } <SENTENCE_END/>

Original Name optimize,top,down

optimize

<SENTENCE_START> { collision jni . bt dbvt optimize top down swig 0 ( swig c ptr , this , bu treshold ) ; } <SENTENCE_END/>

(Copy Probability: 24.5%)

<SENTENCE_START> { collision jni . bt dbvt optimize top down swig 0 ( swig c ptr , this , bu treshold ) ; } <SENTENCE_END/>

top

<SENTENCE_START> { collision jni . bt dbvt optimize top down swig 0 ( swig c ptr , this , bu treshold ) ; } <SENTENCE_END/>

(Copy Probability: 47.7%)

<SENTENCE_START> { collision jni . bt dbvt optimize top down swig 0 ( swig c ptr , this , bu treshold ) ; } <SENTENCE_END/>

down

<SENTENCE_START> { collision jni . bt dbvt optimize top down swig 0 ( swig c ptr , this , bu treshold ) ; } <SENTENCE_END/>

(Copy Probability: 2.2%)

<SENTENCE_START> { collision jni . bt dbvt optimize top down swig 0 ( swig c ptr , this , bu treshold ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { collision jni . bt dbvt optimize top down swig 0 ( swig c ptr , this , bu treshold ) ; } <SENTENCE_END/>

(Copy Probability: 3.4%)

<SENTENCE_START> { collision jni . bt dbvt optimize top down swig 0 ( swig c ptr , this , bu treshold ) ; } <SENTENCE_END/>

Original Name optimize,top,down

optimize

<SENTENCE_START> { collision jni . bt dbvt optimize top down swig 1 ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 20.6%)

<SENTENCE_START> { collision jni . bt dbvt optimize top down swig 1 ( swig c ptr , this ) ; } <SENTENCE_END/>

top

<SENTENCE_START> { collision jni . bt dbvt optimize top down swig 1 ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 46.3%)

<SENTENCE_START> { collision jni . bt dbvt optimize top down swig 1 ( swig c ptr , this ) ; } <SENTENCE_END/>

down

<SENTENCE_START> { collision jni . bt dbvt optimize top down swig 1 ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 1.6%)

<SENTENCE_START> { collision jni . bt dbvt optimize top down swig 1 ( swig c ptr , this ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { collision jni . bt dbvt optimize top down swig 1 ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 3.8%)

<SENTENCE_START> { collision jni . bt dbvt optimize top down swig 1 ( swig c ptr , this ) ; } <SENTENCE_END/>

Original Name optimize,incremental

optimize

<SENTENCE_START> { collision jni . bt dbvt optimize incremental ( swig c ptr , this , passes ) ; } <SENTENCE_END/>

(Copy Probability: 16.0%)

<SENTENCE_START> { collision jni . bt dbvt optimize incremental ( swig c ptr , this , passes ) ; } <SENTENCE_END/>

incremental

<SENTENCE_START> { collision jni . bt dbvt optimize incremental ( swig c ptr , this , passes ) ; } <SENTENCE_END/>

(Copy Probability: 10.6%)

<SENTENCE_START> { collision jni . bt dbvt optimize incremental ( swig c ptr , this , passes ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { collision jni . bt dbvt optimize incremental ( swig c ptr , this , passes ) ; } <SENTENCE_END/>

(Copy Probability: 1.6%)

<SENTENCE_START> { collision jni . bt dbvt optimize incremental ( swig c ptr , this , passes ) ; } <SENTENCE_END/>

Original Name insert

insert

<SENTENCE_START> { long c ptr = collision jni . bt dbvt insert ( swig c ptr , this , bt dbvt aabb mm . get c ptr ( box ) , box , data ) ; return ( c ptr == 0 ) ? null : new bt dbvt node ( c ptr , false ) ; } <SENTENCE_END/>

(Copy Probability: 10.3%)

<SENTENCE_START> { long c ptr = collision jni . bt dbvt insert ( swig c ptr , this , bt dbvt aabb mm . get c ptr ( box ) , box , data ) ; return ( c ptr == 0 ) ? null : new bt dbvt node ( c ptr , false ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { long c ptr = collision jni . bt dbvt insert ( swig c ptr , this , bt dbvt aabb mm . get c ptr ( box ) , box , data ) ; return ( c ptr == 0 ) ? null : new bt dbvt node ( c ptr , false ) ; } <SENTENCE_END/>

(Copy Probability: 44.0%)

<SENTENCE_START> { long c ptr = collision jni . bt dbvt insert ( swig c ptr , this , bt dbvt aabb mm . get c ptr ( box ) , box , data ) ; return ( c ptr == 0 ) ? null : new bt dbvt node ( c ptr , false ) ; } <SENTENCE_END/>

Original Name update

update

<SENTENCE_START> { collision jni . bt dbvt update swig 0 ( swig c ptr , this , bt dbvt node . get c ptr ( leaf ) , leaf , lookahead ) ; } <SENTENCE_END/>

(Copy Probability: 7.1%)

<SENTENCE_START> { collision jni . bt dbvt update swig 0 ( swig c ptr , this , bt dbvt node . get c ptr ( leaf ) , leaf , lookahead ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { collision jni . bt dbvt update swig 0 ( swig c ptr , this , bt dbvt node . get c ptr ( leaf ) , leaf , lookahead ) ; } <SENTENCE_END/>

(Copy Probability: 23.9%)

<SENTENCE_START> { collision jni . bt dbvt update swig 0 ( swig c ptr , this , bt dbvt node . get c ptr ( leaf ) , leaf , lookahead ) ; } <SENTENCE_END/>

Original Name update

update

<SENTENCE_START> { collision jni . bt dbvt update swig 1 ( swig c ptr , this , bt dbvt node . get c ptr ( leaf ) , leaf ) ; } <SENTENCE_END/>

(Copy Probability: 7.2%)

<SENTENCE_START> { collision jni . bt dbvt update swig 1 ( swig c ptr , this , bt dbvt node . get c ptr ( leaf ) , leaf ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { collision jni . bt dbvt update swig 1 ( swig c ptr , this , bt dbvt node . get c ptr ( leaf ) , leaf ) ; } <SENTENCE_END/>

(Copy Probability: 40.1%)

<SENTENCE_START> { collision jni . bt dbvt update swig 1 ( swig c ptr , this , bt dbvt node . get c ptr ( leaf ) , leaf ) ; } <SENTENCE_END/>

Original Name update

update

<SENTENCE_START> { collision jni . bt dbvt update swig 2 ( swig c ptr , this , bt dbvt node . get c ptr ( leaf ) , leaf , bt dbvt aabb mm . get c ptr ( volume ) , volume ) ; } <SENTENCE_END/>

(Copy Probability: 5.6%)

<SENTENCE_START> { collision jni . bt dbvt update swig 2 ( swig c ptr , this , bt dbvt node . get c ptr ( leaf ) , leaf , bt dbvt aabb mm . get c ptr ( volume ) , volume ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { collision jni . bt dbvt update swig 2 ( swig c ptr , this , bt dbvt node . get c ptr ( leaf ) , leaf , bt dbvt aabb mm . get c ptr ( volume ) , volume ) ; } <SENTENCE_END/>

(Copy Probability: 48.5%)

<SENTENCE_START> { collision jni . bt dbvt update swig 2 ( swig c ptr , this , bt dbvt node . get c ptr ( leaf ) , leaf , bt dbvt aabb mm . get c ptr ( volume ) , volume ) ; } <SENTENCE_END/>

Original Name update

update

<SENTENCE_START> { return collision jni . bt dbvt update swig 3 ( swig c ptr , this , bt dbvt node . get c ptr ( leaf ) , leaf , bt dbvt aabb mm . get c ptr ( volume ) , volume , velocity , margin ) ; } <SENTENCE_END/>

(Copy Probability: 4.9%)

<SENTENCE_START> { return collision jni . bt dbvt update swig 3 ( swig c ptr , this , bt dbvt node . get c ptr ( leaf ) , leaf , bt dbvt aabb mm . get c ptr ( volume ) , volume , velocity , margin ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return collision jni . bt dbvt update swig 3 ( swig c ptr , this , bt dbvt node . get c ptr ( leaf ) , leaf , bt dbvt aabb mm . get c ptr ( volume ) , volume , velocity , margin ) ; } <SENTENCE_END/>

(Copy Probability: 43.5%)

<SENTENCE_START> { return collision jni . bt dbvt update swig 3 ( swig c ptr , this , bt dbvt node . get c ptr ( leaf ) , leaf , bt dbvt aabb mm . get c ptr ( volume ) , volume , velocity , margin ) ; } <SENTENCE_END/>

Original Name update

update

<SENTENCE_START> { return collision jni . bt dbvt update swig 4 ( swig c ptr , this , bt dbvt node . get c ptr ( leaf ) , leaf , bt dbvt aabb mm . get c ptr ( volume ) , volume , velocity ) ; } <SENTENCE_END/>

(Copy Probability: 6.5%)

<SENTENCE_START> { return collision jni . bt dbvt update swig 4 ( swig c ptr , this , bt dbvt node . get c ptr ( leaf ) , leaf , bt dbvt aabb mm . get c ptr ( volume ) , volume , velocity ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return collision jni . bt dbvt update swig 4 ( swig c ptr , this , bt dbvt node . get c ptr ( leaf ) , leaf , bt dbvt aabb mm . get c ptr ( volume ) , volume , velocity ) ; } <SENTENCE_END/>

(Copy Probability: 39.4%)

<SENTENCE_START> { return collision jni . bt dbvt update swig 4 ( swig c ptr , this , bt dbvt node . get c ptr ( leaf ) , leaf , bt dbvt aabb mm . get c ptr ( volume ) , volume , velocity ) ; } <SENTENCE_END/>

Original Name update

update

<SENTENCE_START> { return collision jni . bt dbvt update swig 5 ( swig c ptr , this , bt dbvt node . get c ptr ( leaf ) , leaf , bt dbvt aabb mm . get c ptr ( volume ) , volume , margin ) ; } <SENTENCE_END/>

(Copy Probability: 8.2%)

<SENTENCE_START> { return collision jni . bt dbvt update swig 5 ( swig c ptr , this , bt dbvt node . get c ptr ( leaf ) , leaf , bt dbvt aabb mm . get c ptr ( volume ) , volume , margin ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return collision jni . bt dbvt update swig 5 ( swig c ptr , this , bt dbvt node . get c ptr ( leaf ) , leaf , bt dbvt aabb mm . get c ptr ( volume ) , volume , margin ) ; } <SENTENCE_END/>

(Copy Probability: 61.5%)

<SENTENCE_START> { return collision jni . bt dbvt update swig 5 ( swig c ptr , this , bt dbvt node . get c ptr ( leaf ) , leaf , bt dbvt aabb mm . get c ptr ( volume ) , volume , margin ) ; } <SENTENCE_END/>

Original Name remove

remove

<SENTENCE_START> { collision jni . bt dbvt remove ( swig c ptr , this , bt dbvt node . get c ptr ( leaf ) , leaf ) ; } <SENTENCE_END/>

(Copy Probability: 4.2%)

<SENTENCE_START> { collision jni . bt dbvt remove ( swig c ptr , this , bt dbvt node . get c ptr ( leaf ) , leaf ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { collision jni . bt dbvt remove ( swig c ptr , this , bt dbvt node . get c ptr ( leaf ) , leaf ) ; } <SENTENCE_END/>

(Copy Probability: 50.1%)

<SENTENCE_START> { collision jni . bt dbvt remove ( swig c ptr , this , bt dbvt node . get c ptr ( leaf ) , leaf ) ; } <SENTENCE_END/>

Original Name write

write

<SENTENCE_START> { collision jni . bt dbvt write ( swig c ptr , this , bt dbvt . i writer . get c ptr ( iwriter ) , iwriter ) ; } <SENTENCE_END/>

(Copy Probability: 5.2%)

<SENTENCE_START> { collision jni . bt dbvt write ( swig c ptr , this , bt dbvt . i writer . get c ptr ( iwriter ) , iwriter ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { collision jni . bt dbvt write ( swig c ptr , this , bt dbvt . i writer . get c ptr ( iwriter ) , iwriter ) ; } <SENTENCE_END/>

(Copy Probability: 15.6%)

<SENTENCE_START> { collision jni . bt dbvt write ( swig c ptr , this , bt dbvt . i writer . get c ptr ( iwriter ) , iwriter ) ; } <SENTENCE_END/>

Original Name clone

clone

<SENTENCE_START> { collision jni . bt dbvt clone swig 0 ( swig c ptr , this , bt dbvt . get c ptr ( dest ) , dest , bt dbvt . i clone . get c ptr ( iclone ) , iclone ) ; } <SENTENCE_END/>

(Copy Probability: 9.2%)

<SENTENCE_START> { collision jni . bt dbvt clone swig 0 ( swig c ptr , this , bt dbvt . get c ptr ( dest ) , dest , bt dbvt . i clone . get c ptr ( iclone ) , iclone ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { collision jni . bt dbvt clone swig 0 ( swig c ptr , this , bt dbvt . get c ptr ( dest ) , dest , bt dbvt . i clone . get c ptr ( iclone ) , iclone ) ; } <SENTENCE_END/>

(Copy Probability: 20.5%)

<SENTENCE_START> { collision jni . bt dbvt clone swig 0 ( swig c ptr , this , bt dbvt . get c ptr ( dest ) , dest , bt dbvt . i clone . get c ptr ( iclone ) , iclone ) ; } <SENTENCE_END/>

Original Name clone

clone

<SENTENCE_START> { collision jni . bt dbvt clone swig 1 ( swig c ptr , this , bt dbvt . get c ptr ( dest ) , dest ) ; } <SENTENCE_END/>

(Copy Probability: 10.0%)

<SENTENCE_START> { collision jni . bt dbvt clone swig 1 ( swig c ptr , this , bt dbvt . get c ptr ( dest ) , dest ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { collision jni . bt dbvt clone swig 1 ( swig c ptr , this , bt dbvt . get c ptr ( dest ) , dest ) ; } <SENTENCE_END/>

(Copy Probability: 29.0%)

<SENTENCE_START> { collision jni . bt dbvt clone swig 1 ( swig c ptr , this , bt dbvt . get c ptr ( dest ) , dest ) ; } <SENTENCE_END/>

Original Name maxdepth

maxdepth

<SENTENCE_START> { return collision jni . bt dbvt maxdepth ( bt dbvt node . get c ptr ( node ) , node ) ; } <SENTENCE_END/>

(Copy Probability: 1.4%)

<SENTENCE_START> { return collision jni . bt dbvt maxdepth ( bt dbvt node . get c ptr ( node ) , node ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return collision jni . bt dbvt maxdepth ( bt dbvt node . get c ptr ( node ) , node ) ; } <SENTENCE_END/>

(Copy Probability: 54.8%)

<SENTENCE_START> { return collision jni . bt dbvt maxdepth ( bt dbvt node . get c ptr ( node ) , node ) ; } <SENTENCE_END/>

Original Name count,leaves

count

<SENTENCE_START> { return collision jni . bt dbvt count leaves ( bt dbvt node . get c ptr ( node ) , node ) ; } <SENTENCE_END/>

(Copy Probability: 1.4%)

<SENTENCE_START> { return collision jni . bt dbvt count leaves ( bt dbvt node . get c ptr ( node ) , node ) ; } <SENTENCE_END/>

leaves

<SENTENCE_START> { return collision jni . bt dbvt count leaves ( bt dbvt node . get c ptr ( node ) , node ) ; } <SENTENCE_END/>

(Copy Probability: 47.0%)

<SENTENCE_START> { return collision jni . bt dbvt count leaves ( bt dbvt node . get c ptr ( node ) , node ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return collision jni . bt dbvt count leaves ( bt dbvt node . get c ptr ( node ) , node ) ; } <SENTENCE_END/>

(Copy Probability: 5.9%)

<SENTENCE_START> { return collision jni . bt dbvt count leaves ( bt dbvt node . get c ptr ( node ) , node ) ; } <SENTENCE_END/>

Original Name extract,leaves

extract

<SENTENCE_START> { collision jni . bt dbvt extract leaves ( bt dbvt node . get c ptr ( node ) , node , swigtype p bt aligned object array t bt dbvt node const p t . get c ptr ( leaves ) ) ; } <SENTENCE_END/>

(Copy Probability: 3.1%)

<SENTENCE_START> { collision jni . bt dbvt extract leaves ( bt dbvt node . get c ptr ( node ) , node , swigtype p bt aligned object array t bt dbvt node const p t . get c ptr ( leaves ) ) ; } <SENTENCE_END/>

leaves

<SENTENCE_START> { collision jni . bt dbvt extract leaves ( bt dbvt node . get c ptr ( node ) , node , swigtype p bt aligned object array t bt dbvt node const p t . get c ptr ( leaves ) ) ; } <SENTENCE_END/>

(Copy Probability: 58.7%)

<SENTENCE_START> { collision jni . bt dbvt extract leaves ( bt dbvt node . get c ptr ( node ) , node , swigtype p bt aligned object array t bt dbvt node const p t . get c ptr ( leaves ) ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { collision jni . bt dbvt extract leaves ( bt dbvt node . get c ptr ( node ) , node , swigtype p bt aligned object array t bt dbvt node const p t . get c ptr ( leaves ) ) ; } <SENTENCE_END/>

(Copy Probability: 6.3%)

<SENTENCE_START> { collision jni . bt dbvt extract leaves ( bt dbvt node . get c ptr ( node ) , node , swigtype p bt aligned object array t bt dbvt node const p t . get c ptr ( leaves ) ) ; } <SENTENCE_END/>

Original Name benchmark

benchmark

<SENTENCE_START> { collision jni . bt dbvt benchmark ( ) ; } <SENTENCE_END/>

(Copy Probability: 0.7%)

<SENTENCE_START> { collision jni . bt dbvt benchmark ( ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { collision jni . bt dbvt benchmark ( ) ; } <SENTENCE_END/>

(Copy Probability: 0.2%)

<SENTENCE_START> { collision jni . bt dbvt benchmark ( ) ; } <SENTENCE_END/>

Original Name enum,nodes

enum

<SENTENCE_START> { collision jni . bt dbvt enum nodes ( bt dbvt node . get c ptr ( root ) , root , i collide . get c ptr ( policy ) , policy ) ; } <SENTENCE_END/>

(Copy Probability: 2.8%)

<SENTENCE_START> { collision jni . bt dbvt enum nodes ( bt dbvt node . get c ptr ( root ) , root , i collide . get c ptr ( policy ) , policy ) ; } <SENTENCE_END/>

nodes

<SENTENCE_START> { collision jni . bt dbvt enum nodes ( bt dbvt node . get c ptr ( root ) , root , i collide . get c ptr ( policy ) , policy ) ; } <SENTENCE_END/>

(Copy Probability: 76.4%)

<SENTENCE_START> { collision jni . bt dbvt enum nodes ( bt dbvt node . get c ptr ( root ) , root , i collide . get c ptr ( policy ) , policy ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { collision jni . bt dbvt enum nodes ( bt dbvt node . get c ptr ( root ) , root , i collide . get c ptr ( policy ) , policy ) ; } <SENTENCE_END/>

(Copy Probability: 14.9%)

<SENTENCE_START> { collision jni . bt dbvt enum nodes ( bt dbvt node . get c ptr ( root ) , root , i collide . get c ptr ( policy ) , policy ) ; } <SENTENCE_END/>

Original Name enum,leaves

enum

<SENTENCE_START> { collision jni . bt dbvt enum leaves ( bt dbvt node . get c ptr ( root ) , root , i collide . get c ptr ( policy ) , policy ) ; } <SENTENCE_END/>

(Copy Probability: 2.5%)

<SENTENCE_START> { collision jni . bt dbvt enum leaves ( bt dbvt node . get c ptr ( root ) , root , i collide . get c ptr ( policy ) , policy ) ; } <SENTENCE_END/>

leaves

<SENTENCE_START> { collision jni . bt dbvt enum leaves ( bt dbvt node . get c ptr ( root ) , root , i collide . get c ptr ( policy ) , policy ) ; } <SENTENCE_END/>

(Copy Probability: 66.8%)

<SENTENCE_START> { collision jni . bt dbvt enum leaves ( bt dbvt node . get c ptr ( root ) , root , i collide . get c ptr ( policy ) , policy ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { collision jni . bt dbvt enum leaves ( bt dbvt node . get c ptr ( root ) , root , i collide . get c ptr ( policy ) , policy ) ; } <SENTENCE_END/>

(Copy Probability: 7.7%)

<SENTENCE_START> { collision jni . bt dbvt enum leaves ( bt dbvt node . get c ptr ( root ) , root , i collide . get c ptr ( policy ) , policy ) ; } <SENTENCE_END/>

Original Name collide,tt

collide

<SENTENCE_START> { collision jni . bt dbvt collide tt ( swig c ptr , this , bt dbvt node . get c ptr ( root 0 ) , root 0 , bt dbvt node . get c ptr ( root 1 ) , root 1 , i collide . get c ptr ( policy ) , policy ) ; } <SENTENCE_END/>

(Copy Probability: 11.4%)

<SENTENCE_START> { collision jni . bt dbvt collide tt ( swig c ptr , this , bt dbvt node . get c ptr ( root 0 ) , root 0 , bt dbvt node . get c ptr ( root 1 ) , root 1 , i collide . get c ptr ( policy ) , policy ) ; } <SENTENCE_END/>

tt

<SENTENCE_START> { collision jni . bt dbvt collide tt ( swig c ptr , this , bt dbvt node . get c ptr ( root 0 ) , root 0 , bt dbvt node . get c ptr ( root 1 ) , root 1 , i collide . get c ptr ( policy ) , policy ) ; } <SENTENCE_END/>

(Copy Probability: 56.7%)

<SENTENCE_START> { collision jni . bt dbvt collide tt ( swig c ptr , this , bt dbvt node . get c ptr ( root 0 ) , root 0 , bt dbvt node . get c ptr ( root 1 ) , root 1 , i collide . get c ptr ( policy ) , policy ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { collision jni . bt dbvt collide tt ( swig c ptr , this , bt dbvt node . get c ptr ( root 0 ) , root 0 , bt dbvt node . get c ptr ( root 1 ) , root 1 , i collide . get c ptr ( policy ) , policy ) ; } <SENTENCE_END/>

(Copy Probability: 5.2%)

<SENTENCE_START> { collision jni . bt dbvt collide tt ( swig c ptr , this , bt dbvt node . get c ptr ( root 0 ) , root 0 , bt dbvt node . get c ptr ( root 1 ) , root 1 , i collide . get c ptr ( policy ) , policy ) ; } <SENTENCE_END/>

Original Name collide,t,tpersistent,stack

collide

<SENTENCE_START> { collision jni . bt dbvt collide t tpersistent stack ( swig c ptr , this , bt dbvt node . get c ptr ( root 0 ) , root 0 , bt dbvt node . get c ptr ( root 1 ) , root 1 , i collide . get c ptr ( policy ) , policy ) ; } <SENTENCE_END/>

(Copy Probability: 20.6%)

<SENTENCE_START> { collision jni . bt dbvt collide t tpersistent stack ( swig c ptr , this , bt dbvt node . get c ptr ( root 0 ) , root 0 , bt dbvt node . get c ptr ( root 1 ) , root 1 , i collide . get c ptr ( policy ) , policy ) ; } <SENTENCE_END/>

t

<SENTENCE_START> { collision jni . bt dbvt collide t tpersistent stack ( swig c ptr , this , bt dbvt node . get c ptr ( root 0 ) , root 0 , bt dbvt node . get c ptr ( root 1 ) , root 1 , i collide . get c ptr ( policy ) , policy ) ; } <SENTENCE_END/>

(Copy Probability: 96.0%)

<SENTENCE_START> { collision jni . bt dbvt collide t tpersistent stack ( swig c ptr , this , bt dbvt node . get c ptr ( root 0 ) , root 0 , bt dbvt node . get c ptr ( root 1 ) , root 1 , i collide . get c ptr ( policy ) , policy ) ; } <SENTENCE_END/>

tpersistent

<SENTENCE_START> { collision jni . bt dbvt collide t tpersistent stack ( swig c ptr , this , bt dbvt node . get c ptr ( root 0 ) , root 0 , bt dbvt node . get c ptr ( root 1 ) , root 1 , i collide . get c ptr ( policy ) , policy ) ; } <SENTENCE_END/>

(Copy Probability: 5.6%)

<SENTENCE_START> { collision jni . bt dbvt collide t tpersistent stack ( swig c ptr , this , bt dbvt node . get c ptr ( root 0 ) , root 0 , bt dbvt node . get c ptr ( root 1 ) , root 1 , i collide . get c ptr ( policy ) , policy ) ; } <SENTENCE_END/>

stack

<SENTENCE_START> { collision jni . bt dbvt collide t tpersistent stack ( swig c ptr , this , bt dbvt node . get c ptr ( root 0 ) , root 0 , bt dbvt node . get c ptr ( root 1 ) , root 1 , i collide . get c ptr ( policy ) , policy ) ; } <SENTENCE_END/>

(Copy Probability: 2.8%)

<SENTENCE_START> { collision jni . bt dbvt collide t tpersistent stack ( swig c ptr , this , bt dbvt node . get c ptr ( root 0 ) , root 0 , bt dbvt node . get c ptr ( root 1 ) , root 1 , i collide . get c ptr ( policy ) , policy ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { collision jni . bt dbvt collide t tpersistent stack ( swig c ptr , this , bt dbvt node . get c ptr ( root 0 ) , root 0 , bt dbvt node . get c ptr ( root 1 ) , root 1 , i collide . get c ptr ( policy ) , policy ) ; } <SENTENCE_END/>

(Copy Probability: 3.8%)

<SENTENCE_START> { collision jni . bt dbvt collide t tpersistent stack ( swig c ptr , this , bt dbvt node . get c ptr ( root 0 ) , root 0 , bt dbvt node . get c ptr ( root 1 ) , root 1 , i collide . get c ptr ( policy ) , policy ) ; } <SENTENCE_END/>

Original Name collide,tv

collide

<SENTENCE_START> { collision jni . bt dbvt collide tv ( swig c ptr , this , bt dbvt node . get c ptr ( root ) , root , bt dbvt aabb mm . get c ptr ( volume ) , volume , i collide . get c ptr ( policy ) , policy ) ; } <SENTENCE_END/>

(Copy Probability: 11.9%)

<SENTENCE_START> { collision jni . bt dbvt collide tv ( swig c ptr , this , bt dbvt node . get c ptr ( root ) , root , bt dbvt aabb mm . get c ptr ( volume ) , volume , i collide . get c ptr ( policy ) , policy ) ; } <SENTENCE_END/>

tv

<SENTENCE_START> { collision jni . bt dbvt collide tv ( swig c ptr , this , bt dbvt node . get c ptr ( root ) , root , bt dbvt aabb mm . get c ptr ( volume ) , volume , i collide . get c ptr ( policy ) , policy ) ; } <SENTENCE_END/>

(Copy Probability: 53.0%)

<SENTENCE_START> { collision jni . bt dbvt collide tv ( swig c ptr , this , bt dbvt node . get c ptr ( root ) , root , bt dbvt aabb mm . get c ptr ( volume ) , volume , i collide . get c ptr ( policy ) , policy ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { collision jni . bt dbvt collide tv ( swig c ptr , this , bt dbvt node . get c ptr ( root ) , root , bt dbvt aabb mm . get c ptr ( volume ) , volume , i collide . get c ptr ( policy ) , policy ) ; } <SENTENCE_END/>

(Copy Probability: 6.5%)

<SENTENCE_START> { collision jni . bt dbvt collide tv ( swig c ptr , this , bt dbvt node . get c ptr ( root ) , root , bt dbvt aabb mm . get c ptr ( volume ) , volume , i collide . get c ptr ( policy ) , policy ) ; } <SENTENCE_END/>

Original Name ray,test

ray

<SENTENCE_START> { collision jni . bt dbvt ray test ( bt dbvt node . get c ptr ( root ) , root , ray from , ray to , i collide . get c ptr ( policy ) , policy ) ; } <SENTENCE_END/>

(Copy Probability: 5.0%)

<SENTENCE_START> { collision jni . bt dbvt ray test ( bt dbvt node . get c ptr ( root ) , root , ray from , ray to , i collide . get c ptr ( policy ) , policy ) ; } <SENTENCE_END/>

test

<SENTENCE_START> { collision jni . bt dbvt ray test ( bt dbvt node . get c ptr ( root ) , root , ray from , ray to , i collide . get c ptr ( policy ) , policy ) ; } <SENTENCE_END/>

(Copy Probability: 85.0%)

<SENTENCE_START> { collision jni . bt dbvt ray test ( bt dbvt node . get c ptr ( root ) , root , ray from , ray to , i collide . get c ptr ( policy ) , policy ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { collision jni . bt dbvt ray test ( bt dbvt node . get c ptr ( root ) , root , ray from , ray to , i collide . get c ptr ( policy ) , policy ) ; } <SENTENCE_END/>

(Copy Probability: 23.8%)

<SENTENCE_START> { collision jni . bt dbvt ray test ( bt dbvt node . get c ptr ( root ) , root , ray from , ray to , i collide . get c ptr ( policy ) , policy ) ; } <SENTENCE_END/>

Original Name ray,test,internal

ray

<SENTENCE_START> { collision jni . bt dbvt ray test internal ( swig c ptr , this , bt dbvt node . get c ptr ( root ) , root , ray from , ray to , ray direction inverse , signs , lambda max , aabb min , aabb max , i collide . get c ptr ( policy ) , policy ) ; } <SENTENCE_END/>

(Copy Probability: 19.4%)

<SENTENCE_START> { collision jni . bt dbvt ray test internal ( swig c ptr , this , bt dbvt node . get c ptr ( root ) , root , ray from , ray to , ray direction inverse , signs , lambda max , aabb min , aabb max , i collide . get c ptr ( policy ) , policy ) ; } <SENTENCE_END/>

test

<SENTENCE_START> { collision jni . bt dbvt ray test internal ( swig c ptr , this , bt dbvt node . get c ptr ( root ) , root , ray from , ray to , ray direction inverse , signs , lambda max , aabb min , aabb max , i collide . get c ptr ( policy ) , policy ) ; } <SENTENCE_END/>

(Copy Probability: 89.9%)

<SENTENCE_START> { collision jni . bt dbvt ray test internal ( swig c ptr , this , bt dbvt node . get c ptr ( root ) , root , ray from , ray to , ray direction inverse , signs , lambda max , aabb min , aabb max , i collide . get c ptr ( policy ) , policy ) ; } <SENTENCE_END/>

internal

<SENTENCE_START> { collision jni . bt dbvt ray test internal ( swig c ptr , this , bt dbvt node . get c ptr ( root ) , root , ray from , ray to , ray direction inverse , signs , lambda max , aabb min , aabb max , i collide . get c ptr ( policy ) , policy ) ; } <SENTENCE_END/>

(Copy Probability: 5.1%)

<SENTENCE_START> { collision jni . bt dbvt ray test internal ( swig c ptr , this , bt dbvt node . get c ptr ( root ) , root , ray from , ray to , ray direction inverse , signs , lambda max , aabb min , aabb max , i collide . get c ptr ( policy ) , policy ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { collision jni . bt dbvt ray test internal ( swig c ptr , this , bt dbvt node . get c ptr ( root ) , root , ray from , ray to , ray direction inverse , signs , lambda max , aabb min , aabb max , i collide . get c ptr ( policy ) , policy ) ; } <SENTENCE_END/>

(Copy Probability: 3.6%)

<SENTENCE_START> { collision jni . bt dbvt ray test internal ( swig c ptr , this , bt dbvt node . get c ptr ( root ) , root , ray from , ray to , ray direction inverse , signs , lambda max , aabb min , aabb max , i collide . get c ptr ( policy ) , policy ) ; } <SENTENCE_END/>

Original Name collide,kdop

collide

<SENTENCE_START> { assert offsets . is direct ( ) : "Buffer must be allocated direct." ; { collision jni . bt dbvt collide kdop swig 0 ( bt dbvt node . get c ptr ( root ) , root , bt vector 3 . get c ptr ( normals ) , normals , offsets , count , i collide . get c ptr ( policy ) , policy ) ; } } <SENTENCE_END/>

(Copy Probability: 20.6%)

<SENTENCE_START> { assert offsets . is direct ( ) : "Buffer must be allocated direct." ; { collision jni . bt dbvt collide kdop swig 0 ( bt dbvt node . get c ptr ( root ) , root , bt vector 3 . get c ptr ( normals ) , normals , offsets , count , i collide . get c ptr ( policy ) , policy ) ; } } <SENTENCE_END/>

kdop

<SENTENCE_START> { assert offsets . is direct ( ) : "Buffer must be allocated direct." ; { collision jni . bt dbvt collide kdop swig 0 ( bt dbvt node . get c ptr ( root ) , root , bt vector 3 . get c ptr ( normals ) , normals , offsets , count , i collide . get c ptr ( policy ) , policy ) ; } } <SENTENCE_END/>

(Copy Probability: 53.8%)

<SENTENCE_START> { assert offsets . is direct ( ) : "Buffer must be allocated direct." ; { collision jni . bt dbvt collide kdop swig 0 ( bt dbvt node . get c ptr ( root ) , root , bt vector 3 . get c ptr ( normals ) , normals , offsets , count , i collide . get c ptr ( policy ) , policy ) ; } } <SENTENCE_END/>

%END%

<SENTENCE_START> { assert offsets . is direct ( ) : "Buffer must be allocated direct." ; { collision jni . bt dbvt collide kdop swig 0 ( bt dbvt node . get c ptr ( root ) , root , bt vector 3 . get c ptr ( normals ) , normals , offsets , count , i collide . get c ptr ( policy ) , policy ) ; } } <SENTENCE_END/>

(Copy Probability: 4.4%)

<SENTENCE_START> { assert offsets . is direct ( ) : "Buffer must be allocated direct." ; { collision jni . bt dbvt collide kdop swig 0 ( bt dbvt node . get c ptr ( root ) , root , bt vector 3 . get c ptr ( normals ) , normals , offsets , count , i collide . get c ptr ( policy ) , policy ) ; } } <SENTENCE_END/>

Original Name collide,ocl

collide

<SENTENCE_START> { assert offsets . is direct ( ) : "Buffer must be allocated direct." ; { collision jni . bt dbvt collide ocl swig 0 ( bt dbvt node . get c ptr ( root ) , root , bt vector 3 . get c ptr ( normals ) , normals , offsets , sortaxis , count , i collide . get c ptr ( policy ) , policy , fullsort ) ; } } <SENTENCE_END/>

(Copy Probability: 20.1%)

<SENTENCE_START> { assert offsets . is direct ( ) : "Buffer must be allocated direct." ; { collision jni . bt dbvt collide ocl swig 0 ( bt dbvt node . get c ptr ( root ) , root , bt vector 3 . get c ptr ( normals ) , normals , offsets , sortaxis , count , i collide . get c ptr ( policy ) , policy , fullsort ) ; } } <SENTENCE_END/>

ocl

<SENTENCE_START> { assert offsets . is direct ( ) : "Buffer must be allocated direct." ; { collision jni . bt dbvt collide ocl swig 0 ( bt dbvt node . get c ptr ( root ) , root , bt vector 3 . get c ptr ( normals ) , normals , offsets , sortaxis , count , i collide . get c ptr ( policy ) , policy , fullsort ) ; } } <SENTENCE_END/>

(Copy Probability: 52.9%)

<SENTENCE_START> { assert offsets . is direct ( ) : "Buffer must be allocated direct." ; { collision jni . bt dbvt collide ocl swig 0 ( bt dbvt node . get c ptr ( root ) , root , bt vector 3 . get c ptr ( normals ) , normals , offsets , sortaxis , count , i collide . get c ptr ( policy ) , policy , fullsort ) ; } } <SENTENCE_END/>

%END%

<SENTENCE_START> { assert offsets . is direct ( ) : "Buffer must be allocated direct." ; { collision jni . bt dbvt collide ocl swig 0 ( bt dbvt node . get c ptr ( root ) , root , bt vector 3 . get c ptr ( normals ) , normals , offsets , sortaxis , count , i collide . get c ptr ( policy ) , policy , fullsort ) ; } } <SENTENCE_END/>

(Copy Probability: 4.4%)

<SENTENCE_START> { assert offsets . is direct ( ) : "Buffer must be allocated direct." ; { collision jni . bt dbvt collide ocl swig 0 ( bt dbvt node . get c ptr ( root ) , root , bt vector 3 . get c ptr ( normals ) , normals , offsets , sortaxis , count , i collide . get c ptr ( policy ) , policy , fullsort ) ; } } <SENTENCE_END/>

Original Name collide,ocl

collide

<SENTENCE_START> { assert offsets . is direct ( ) : "Buffer must be allocated direct." ; { collision jni . bt dbvt collide ocl swig 1 ( bt dbvt node . get c ptr ( root ) , root , bt vector 3 . get c ptr ( normals ) , normals , offsets , sortaxis , count , i collide . get c ptr ( policy ) , policy ) ; } } <SENTENCE_END/>

(Copy Probability: 21.8%)

<SENTENCE_START> { assert offsets . is direct ( ) : "Buffer must be allocated direct." ; { collision jni . bt dbvt collide ocl swig 1 ( bt dbvt node . get c ptr ( root ) , root , bt vector 3 . get c ptr ( normals ) , normals , offsets , sortaxis , count , i collide . get c ptr ( policy ) , policy ) ; } } <SENTENCE_END/>

ocl

<SENTENCE_START> { assert offsets . is direct ( ) : "Buffer must be allocated direct." ; { collision jni . bt dbvt collide ocl swig 1 ( bt dbvt node . get c ptr ( root ) , root , bt vector 3 . get c ptr ( normals ) , normals , offsets , sortaxis , count , i collide . get c ptr ( policy ) , policy ) ; } } <SENTENCE_END/>

(Copy Probability: 61.9%)

<SENTENCE_START> { assert offsets . is direct ( ) : "Buffer must be allocated direct." ; { collision jni . bt dbvt collide ocl swig 1 ( bt dbvt node . get c ptr ( root ) , root , bt vector 3 . get c ptr ( normals ) , normals , offsets , sortaxis , count , i collide . get c ptr ( policy ) , policy ) ; } } <SENTENCE_END/>

%END%

<SENTENCE_START> { assert offsets . is direct ( ) : "Buffer must be allocated direct." ; { collision jni . bt dbvt collide ocl swig 1 ( bt dbvt node . get c ptr ( root ) , root , bt vector 3 . get c ptr ( normals ) , normals , offsets , sortaxis , count , i collide . get c ptr ( policy ) , policy ) ; } } <SENTENCE_END/>

(Copy Probability: 5.3%)

<SENTENCE_START> { assert offsets . is direct ( ) : "Buffer must be allocated direct." ; { collision jni . bt dbvt collide ocl swig 1 ( bt dbvt node . get c ptr ( root ) , root , bt vector 3 . get c ptr ( normals ) , normals , offsets , sortaxis , count , i collide . get c ptr ( policy ) , policy ) ; } } <SENTENCE_END/>

Original Name collide,tu

collide

<SENTENCE_START> { collision jni . bt dbvt collide tu ( bt dbvt node . get c ptr ( root ) , root , i collide . get c ptr ( policy ) , policy ) ; } <SENTENCE_END/>

(Copy Probability: 3.1%)

<SENTENCE_START> { collision jni . bt dbvt collide tu ( bt dbvt node . get c ptr ( root ) , root , i collide . get c ptr ( policy ) , policy ) ; } <SENTENCE_END/>

tu

<SENTENCE_START> { collision jni . bt dbvt collide tu ( bt dbvt node . get c ptr ( root ) , root , i collide . get c ptr ( policy ) , policy ) ; } <SENTENCE_END/>

(Copy Probability: 80.1%)

<SENTENCE_START> { collision jni . bt dbvt collide tu ( bt dbvt node . get c ptr ( root ) , root , i collide . get c ptr ( policy ) , policy ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { collision jni . bt dbvt collide tu ( bt dbvt node . get c ptr ( root ) , root , i collide . get c ptr ( policy ) , policy ) ; } <SENTENCE_END/>

(Copy Probability: 9.1%)

<SENTENCE_START> { collision jni . bt dbvt collide tu ( bt dbvt node . get c ptr ( root ) , root , i collide . get c ptr ( policy ) , policy ) ; } <SENTENCE_END/>

Original Name nearest

nearest

<SENTENCE_START> { assert i . is direct ( ) : "Buffer must be allocated direct." ; { return collision jni . bt dbvt nearest ( i , bt dbvt . s stk nps . get c ptr ( a ) , a , v , l , h ) ; } } <SENTENCE_END/>

(Copy Probability: 3.3%)

<SENTENCE_START> { assert i . is direct ( ) : "Buffer must be allocated direct." ; { return collision jni . bt dbvt nearest ( i , bt dbvt . s stk nps . get c ptr ( a ) , a , v , l , h ) ; } } <SENTENCE_END/>

%END%

<SENTENCE_START> { assert i . is direct ( ) : "Buffer must be allocated direct." ; { return collision jni . bt dbvt nearest ( i , bt dbvt . s stk nps . get c ptr ( a ) , a , v , l , h ) ; } } <SENTENCE_END/>

(Copy Probability: 9.4%)

<SENTENCE_START> { assert i . is direct ( ) : "Buffer must be allocated direct." ; { return collision jni . bt dbvt nearest ( i , bt dbvt . s stk nps . get c ptr ( a ) , a , v , l , h ) ; } } <SENTENCE_END/>

Original Name allocate

allocate

<SENTENCE_START> { return collision jni . bt dbvt allocate ( swigtype p bt aligned object array t int t . get c ptr ( ifree ) , swigtype p bt aligned object array t bt dbvt s stk nps t . get c ptr ( stock ) , bt dbvt . s stk nps . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

(Copy Probability: 3.4%)

<SENTENCE_START> { return collision jni . bt dbvt allocate ( swigtype p bt aligned object array t int t . get c ptr ( ifree ) , swigtype p bt aligned object array t bt dbvt s stk nps t . get c ptr ( stock ) , bt dbvt . s stk nps . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return collision jni . bt dbvt allocate ( swigtype p bt aligned object array t int t . get c ptr ( ifree ) , swigtype p bt aligned object array t bt dbvt s stk nps t . get c ptr ( stock ) , bt dbvt . s stk nps . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

(Copy Probability: 9.7%)

<SENTENCE_START> { return collision jni . bt dbvt allocate ( swigtype p bt aligned object array t int t . get c ptr ( ifree ) , swigtype p bt aligned object array t bt dbvt s stk nps t . get c ptr ( stock ) , bt dbvt . s stk nps . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

Original Name collide,kdop

collide

<SENTENCE_START> { assert normals . is direct ( ) : "Buffer must be allocated direct." ; assert offsets . is direct ( ) : "Buffer must be allocated direct." ; { collision jni . bt dbvt collide kdop swig 1 ( bt dbvt node . get c ptr ( root ) , root , normals , offsets , count , i collide . get c ptr ( policy ) , policy ) ; } } <SENTENCE_END/>

(Copy Probability: 19.2%)

<SENTENCE_START> { assert normals . is direct ( ) : "Buffer must be allocated direct." ; assert offsets . is direct ( ) : "Buffer must be allocated direct." ; { collision jni . bt dbvt collide kdop swig 1 ( bt dbvt node . get c ptr ( root ) , root , normals , offsets , count , i collide . get c ptr ( policy ) , policy ) ; } } <SENTENCE_END/>

kdop

<SENTENCE_START> { assert normals . is direct ( ) : "Buffer must be allocated direct." ; assert offsets . is direct ( ) : "Buffer must be allocated direct." ; { collision jni . bt dbvt collide kdop swig 1 ( bt dbvt node . get c ptr ( root ) , root , normals , offsets , count , i collide . get c ptr ( policy ) , policy ) ; } } <SENTENCE_END/>

(Copy Probability: 45.2%)

<SENTENCE_START> { assert normals . is direct ( ) : "Buffer must be allocated direct." ; assert offsets . is direct ( ) : "Buffer must be allocated direct." ; { collision jni . bt dbvt collide kdop swig 1 ( bt dbvt node . get c ptr ( root ) , root , normals , offsets , count , i collide . get c ptr ( policy ) , policy ) ; } } <SENTENCE_END/>

%END%

<SENTENCE_START> { assert normals . is direct ( ) : "Buffer must be allocated direct." ; assert offsets . is direct ( ) : "Buffer must be allocated direct." ; { collision jni . bt dbvt collide kdop swig 1 ( bt dbvt node . get c ptr ( root ) , root , normals , offsets , count , i collide . get c ptr ( policy ) , policy ) ; } } <SENTENCE_END/>

(Copy Probability: 5.7%)

<SENTENCE_START> { assert normals . is direct ( ) : "Buffer must be allocated direct." ; assert offsets . is direct ( ) : "Buffer must be allocated direct." ; { collision jni . bt dbvt collide kdop swig 1 ( bt dbvt node . get c ptr ( root ) , root , normals , offsets , count , i collide . get c ptr ( policy ) , policy ) ; } } <SENTENCE_END/>

Original Name collide,ocl

collide

<SENTENCE_START> { assert normals . is direct ( ) : "Buffer must be allocated direct." ; assert offsets . is direct ( ) : "Buffer must be allocated direct." ; { collision jni . bt dbvt collide ocl swig 2 ( bt dbvt node . get c ptr ( root ) , root , normals , offsets , sortaxis , count , i collide . get c ptr ( policy ) , policy , fullsort ) ; } } <SENTENCE_END/>

(Copy Probability: 15.4%)

<SENTENCE_START> { assert normals . is direct ( ) : "Buffer must be allocated direct." ; assert offsets . is direct ( ) : "Buffer must be allocated direct." ; { collision jni . bt dbvt collide ocl swig 2 ( bt dbvt node . get c ptr ( root ) , root , normals , offsets , sortaxis , count , i collide . get c ptr ( policy ) , policy , fullsort ) ; } } <SENTENCE_END/>

ocl

<SENTENCE_START> { assert normals . is direct ( ) : "Buffer must be allocated direct." ; assert offsets . is direct ( ) : "Buffer must be allocated direct." ; { collision jni . bt dbvt collide ocl swig 2 ( bt dbvt node . get c ptr ( root ) , root , normals , offsets , sortaxis , count , i collide . get c ptr ( policy ) , policy , fullsort ) ; } } <SENTENCE_END/>

(Copy Probability: 40.4%)

<SENTENCE_START> { assert normals . is direct ( ) : "Buffer must be allocated direct." ; assert offsets . is direct ( ) : "Buffer must be allocated direct." ; { collision jni . bt dbvt collide ocl swig 2 ( bt dbvt node . get c ptr ( root ) , root , normals , offsets , sortaxis , count , i collide . get c ptr ( policy ) , policy , fullsort ) ; } } <SENTENCE_END/>

%END%

<SENTENCE_START> { assert normals . is direct ( ) : "Buffer must be allocated direct." ; assert offsets . is direct ( ) : "Buffer must be allocated direct." ; { collision jni . bt dbvt collide ocl swig 2 ( bt dbvt node . get c ptr ( root ) , root , normals , offsets , sortaxis , count , i collide . get c ptr ( policy ) , policy , fullsort ) ; } } <SENTENCE_END/>

(Copy Probability: 4.8%)

<SENTENCE_START> { assert normals . is direct ( ) : "Buffer must be allocated direct." ; assert offsets . is direct ( ) : "Buffer must be allocated direct." ; { collision jni . bt dbvt collide ocl swig 2 ( bt dbvt node . get c ptr ( root ) , root , normals , offsets , sortaxis , count , i collide . get c ptr ( policy ) , policy , fullsort ) ; } } <SENTENCE_END/>

Original Name collide,ocl

collide

<SENTENCE_START> { assert normals . is direct ( ) : "Buffer must be allocated direct." ; assert offsets . is direct ( ) : "Buffer must be allocated direct." ; { collision jni . bt dbvt collide ocl swig 3 ( bt dbvt node . get c ptr ( root ) , root , normals , offsets , sortaxis , count , i collide . get c ptr ( policy ) , policy ) ; } } <SENTENCE_END/>

(Copy Probability: 15.6%)

<SENTENCE_START> { assert normals . is direct ( ) : "Buffer must be allocated direct." ; assert offsets . is direct ( ) : "Buffer must be allocated direct." ; { collision jni . bt dbvt collide ocl swig 3 ( bt dbvt node . get c ptr ( root ) , root , normals , offsets , sortaxis , count , i collide . get c ptr ( policy ) , policy ) ; } } <SENTENCE_END/>

ocl

<SENTENCE_START> { assert normals . is direct ( ) : "Buffer must be allocated direct." ; assert offsets . is direct ( ) : "Buffer must be allocated direct." ; { collision jni . bt dbvt collide ocl swig 3 ( bt dbvt node . get c ptr ( root ) , root , normals , offsets , sortaxis , count , i collide . get c ptr ( policy ) , policy ) ; } } <SENTENCE_END/>

(Copy Probability: 37.5%)

<SENTENCE_START> { assert normals . is direct ( ) : "Buffer must be allocated direct." ; assert offsets . is direct ( ) : "Buffer must be allocated direct." ; { collision jni . bt dbvt collide ocl swig 3 ( bt dbvt node . get c ptr ( root ) , root , normals , offsets , sortaxis , count , i collide . get c ptr ( policy ) , policy ) ; } } <SENTENCE_END/>

%END%

<SENTENCE_START> { assert normals . is direct ( ) : "Buffer must be allocated direct." ; assert offsets . is direct ( ) : "Buffer must be allocated direct." ; { collision jni . bt dbvt collide ocl swig 3 ( bt dbvt node . get c ptr ( root ) , root , normals , offsets , sortaxis , count , i collide . get c ptr ( policy ) , policy ) ; } } <SENTENCE_END/>

(Copy Probability: 4.7%)

<SENTENCE_START> { assert normals . is direct ( ) : "Buffer must be allocated direct." ; assert offsets . is direct ( ) : "Buffer must be allocated direct." ; { collision jni . bt dbvt collide ocl swig 3 ( bt dbvt node . get c ptr ( root ) , root , normals , offsets , sortaxis , count , i collide . get c ptr ( policy ) , policy ) ; } } <SENTENCE_END/>

Original Name initialize

initialize

<SENTENCE_START> { body a = b 1 ; body b = b 2 ; body a . get local point to out ( anchor , local anchor a ) ; body b . get local point to out ( anchor , local anchor b ) ; reference angle = body b . get angle ( ) - body a . get angle ( ) ; } <SENTENCE_END/>

(Copy Probability: 3.0%)

<SENTENCE_START> { body a = b 1 ; body b = b 2 ; body a . get local point to out ( anchor , local anchor a ) ; body b . get local point to out ( anchor , local anchor b ) ; reference angle = body b . get angle ( ) - body a . get angle ( ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { body a = b 1 ; body b = b 2 ; body a . get local point to out ( anchor , local anchor a ) ; body b . get local point to out ( anchor , local anchor b ) ; reference angle = body b . get angle ( ) - body a . get angle ( ) ; } <SENTENCE_END/>

(Copy Probability: 41.5%)

<SENTENCE_START> { body a = b 1 ; body b = b 2 ; body a . get local point to out ( anchor , local anchor a ) ; body b . get local point to out ( anchor , local anchor b ) ; reference angle = body b . get angle ( ) - body a . get angle ( ) ; } <SENTENCE_END/>

Original Name get,c,ptr

get

<SENTENCE_START> { return ( obj == null ) ? 0 : obj . swig c ptr ; } <SENTENCE_END/>

(Copy Probability: 1.5%)

<SENTENCE_START> { return ( obj == null ) ? 0 : obj . swig c ptr ; } <SENTENCE_END/>

c

<SENTENCE_START> { return ( obj == null ) ? 0 : obj . swig c ptr ; } <SENTENCE_END/>

(Copy Probability: 99.7%)

<SENTENCE_START> { return ( obj == null ) ? 0 : obj . swig c ptr ; } <SENTENCE_END/>

ptr

<SENTENCE_START> { return ( obj == null ) ? 0 : obj . swig c ptr ; } <SENTENCE_END/>

(Copy Probability: 99.8%)

<SENTENCE_START> { return ( obj == null ) ? 0 : obj . swig c ptr ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return ( obj == null ) ? 0 : obj . swig c ptr ; } <SENTENCE_END/>

(Copy Probability: 3.7%)

<SENTENCE_START> { return ( obj == null ) ? 0 : obj . swig c ptr ; } <SENTENCE_END/>

Original Name integrate,transform

integrate

<SENTENCE_START> { linear math jni . bt transform util integrate transform ( cur trans , linvel , angvel , time step , predicted transform ) ; } <SENTENCE_END/>

(Copy Probability: 8.9%)

<SENTENCE_START> { linear math jni . bt transform util integrate transform ( cur trans , linvel , angvel , time step , predicted transform ) ; } <SENTENCE_END/>

transform

<SENTENCE_START> { linear math jni . bt transform util integrate transform ( cur trans , linvel , angvel , time step , predicted transform ) ; } <SENTENCE_END/>

(Copy Probability: 92.4%)

<SENTENCE_START> { linear math jni . bt transform util integrate transform ( cur trans , linvel , angvel , time step , predicted transform ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { linear math jni . bt transform util integrate transform ( cur trans , linvel , angvel , time step , predicted transform ) ; } <SENTENCE_END/>

(Copy Probability: 7.1%)

<SENTENCE_START> { linear math jni . bt transform util integrate transform ( cur trans , linvel , angvel , time step , predicted transform ) ; } <SENTENCE_END/>

Original Name calculate,velocity,quaternion

calculate

<SENTENCE_START> { linear math jni . bt transform util calculate velocity quaternion ( pos 0 , pos 1 , orn 0 , orn 1 , time step , lin vel , ang vel ) ; } <SENTENCE_END/>

(Copy Probability: 9.5%)

<SENTENCE_START> { linear math jni . bt transform util calculate velocity quaternion ( pos 0 , pos 1 , orn 0 , orn 1 , time step , lin vel , ang vel ) ; } <SENTENCE_END/>

velocity

<SENTENCE_START> { linear math jni . bt transform util calculate velocity quaternion ( pos 0 , pos 1 , orn 0 , orn 1 , time step , lin vel , ang vel ) ; } <SENTENCE_END/>

(Copy Probability: 98.3%)

<SENTENCE_START> { linear math jni . bt transform util calculate velocity quaternion ( pos 0 , pos 1 , orn 0 , orn 1 , time step , lin vel , ang vel ) ; } <SENTENCE_END/>

quaternion

<SENTENCE_START> { linear math jni . bt transform util calculate velocity quaternion ( pos 0 , pos 1 , orn 0 , orn 1 , time step , lin vel , ang vel ) ; } <SENTENCE_END/>

(Copy Probability: 69.7%)

<SENTENCE_START> { linear math jni . bt transform util calculate velocity quaternion ( pos 0 , pos 1 , orn 0 , orn 1 , time step , lin vel , ang vel ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { linear math jni . bt transform util calculate velocity quaternion ( pos 0 , pos 1 , orn 0 , orn 1 , time step , lin vel , ang vel ) ; } <SENTENCE_END/>

(Copy Probability: 5.9%)

<SENTENCE_START> { linear math jni . bt transform util calculate velocity quaternion ( pos 0 , pos 1 , orn 0 , orn 1 , time step , lin vel , ang vel ) ; } <SENTENCE_END/>

Original Name calculate,diff,axis,angle,quaternion

calculate

<SENTENCE_START> { linear math jni . bt transform util calculate diff axis angle quaternion ( orn 0 , orn 1 a , axis , swigtype p float . get c ptr ( angle ) ) ; } <SENTENCE_END/>

(Copy Probability: 14.4%)

<SENTENCE_START> { linear math jni . bt transform util calculate diff axis angle quaternion ( orn 0 , orn 1 a , axis , swigtype p float . get c ptr ( angle ) ) ; } <SENTENCE_END/>

diff

<SENTENCE_START> { linear math jni . bt transform util calculate diff axis angle quaternion ( orn 0 , orn 1 a , axis , swigtype p float . get c ptr ( angle ) ) ; } <SENTENCE_END/>

(Copy Probability: 99.4%)

<SENTENCE_START> { linear math jni . bt transform util calculate diff axis angle quaternion ( orn 0 , orn 1 a , axis , swigtype p float . get c ptr ( angle ) ) ; } <SENTENCE_END/>

axis

<SENTENCE_START> { linear math jni . bt transform util calculate diff axis angle quaternion ( orn 0 , orn 1 a , axis , swigtype p float . get c ptr ( angle ) ) ; } <SENTENCE_END/>

(Copy Probability: 98.7%)

<SENTENCE_START> { linear math jni . bt transform util calculate diff axis angle quaternion ( orn 0 , orn 1 a , axis , swigtype p float . get c ptr ( angle ) ) ; } <SENTENCE_END/>

angle

<SENTENCE_START> { linear math jni . bt transform util calculate diff axis angle quaternion ( orn 0 , orn 1 a , axis , swigtype p float . get c ptr ( angle ) ) ; } <SENTENCE_END/>

(Copy Probability: 52.4%)

<SENTENCE_START> { linear math jni . bt transform util calculate diff axis angle quaternion ( orn 0 , orn 1 a , axis , swigtype p float . get c ptr ( angle ) ) ; } <SENTENCE_END/>

quaternion

<SENTENCE_START> { linear math jni . bt transform util calculate diff axis angle quaternion ( orn 0 , orn 1 a , axis , swigtype p float . get c ptr ( angle ) ) ; } <SENTENCE_END/>

(Copy Probability: 5.2%)

<SENTENCE_START> { linear math jni . bt transform util calculate diff axis angle quaternion ( orn 0 , orn 1 a , axis , swigtype p float . get c ptr ( angle ) ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { linear math jni . bt transform util calculate diff axis angle quaternion ( orn 0 , orn 1 a , axis , swigtype p float . get c ptr ( angle ) ) ; } <SENTENCE_END/>

(Copy Probability: 5.2%)

<SENTENCE_START> { linear math jni . bt transform util calculate diff axis angle quaternion ( orn 0 , orn 1 a , axis , swigtype p float . get c ptr ( angle ) ) ; } <SENTENCE_END/>

Original Name calculate,velocity

calculate

<SENTENCE_START> { linear math jni . bt transform util calculate velocity ( transform 0 , transform 1 , time step , lin vel , ang vel ) ; } <SENTENCE_END/>

(Copy Probability: 21.4%)

<SENTENCE_START> { linear math jni . bt transform util calculate velocity ( transform 0 , transform 1 , time step , lin vel , ang vel ) ; } <SENTENCE_END/>

velocity

<SENTENCE_START> { linear math jni . bt transform util calculate velocity ( transform 0 , transform 1 , time step , lin vel , ang vel ) ; } <SENTENCE_END/>

(Copy Probability: 99.6%)

<SENTENCE_START> { linear math jni . bt transform util calculate velocity ( transform 0 , transform 1 , time step , lin vel , ang vel ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { linear math jni . bt transform util calculate velocity ( transform 0 , transform 1 , time step , lin vel , ang vel ) ; } <SENTENCE_END/>

(Copy Probability: 91.8%)

<SENTENCE_START> { linear math jni . bt transform util calculate velocity ( transform 0 , transform 1 , time step , lin vel , ang vel ) ; } <SENTENCE_END/>

Original Name calculate,diff,axis,angle

calculate

<SENTENCE_START> { linear math jni . bt transform util calculate diff axis angle ( transform 0 , transform 1 , axis , swigtype p float . get c ptr ( angle ) ) ; } <SENTENCE_END/>

(Copy Probability: 18.7%)

<SENTENCE_START> { linear math jni . bt transform util calculate diff axis angle ( transform 0 , transform 1 , axis , swigtype p float . get c ptr ( angle ) ) ; } <SENTENCE_END/>

diff

<SENTENCE_START> { linear math jni . bt transform util calculate diff axis angle ( transform 0 , transform 1 , axis , swigtype p float . get c ptr ( angle ) ) ; } <SENTENCE_END/>

(Copy Probability: 99.6%)

<SENTENCE_START> { linear math jni . bt transform util calculate diff axis angle ( transform 0 , transform 1 , axis , swigtype p float . get c ptr ( angle ) ) ; } <SENTENCE_END/>

axis

<SENTENCE_START> { linear math jni . bt transform util calculate diff axis angle ( transform 0 , transform 1 , axis , swigtype p float . get c ptr ( angle ) ) ; } <SENTENCE_END/>

(Copy Probability: 98.6%)

<SENTENCE_START> { linear math jni . bt transform util calculate diff axis angle ( transform 0 , transform 1 , axis , swigtype p float . get c ptr ( angle ) ) ; } <SENTENCE_END/>

angle

<SENTENCE_START> { linear math jni . bt transform util calculate diff axis angle ( transform 0 , transform 1 , axis , swigtype p float . get c ptr ( angle ) ) ; } <SENTENCE_END/>

(Copy Probability: 31.6%)

<SENTENCE_START> { linear math jni . bt transform util calculate diff axis angle ( transform 0 , transform 1 , axis , swigtype p float . get c ptr ( angle ) ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { linear math jni . bt transform util calculate diff axis angle ( transform 0 , transform 1 , axis , swigtype p float . get c ptr ( angle ) ) ; } <SENTENCE_END/>

(Copy Probability: 5.6%)

<SENTENCE_START> { linear math jni . bt transform util calculate diff axis angle ( transform 0 , transform 1 , axis , swigtype p float . get c ptr ( angle ) ) ; } <SENTENCE_END/>

Original Name get,c,ptr

get

<SENTENCE_START> { return ( obj == null ) ? 0 : obj . swig c ptr ; } <SENTENCE_END/>

(Copy Probability: 1.5%)

<SENTENCE_START> { return ( obj == null ) ? 0 : obj . swig c ptr ; } <SENTENCE_END/>

c

<SENTENCE_START> { return ( obj == null ) ? 0 : obj . swig c ptr ; } <SENTENCE_END/>

(Copy Probability: 99.7%)

<SENTENCE_START> { return ( obj == null ) ? 0 : obj . swig c ptr ; } <SENTENCE_END/>

ptr

<SENTENCE_START> { return ( obj == null ) ? 0 : obj . swig c ptr ; } <SENTENCE_END/>

(Copy Probability: 99.8%)

<SENTENCE_START> { return ( obj == null ) ? 0 : obj . swig c ptr ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return ( obj == null ) ? 0 : obj . swig c ptr ; } <SENTENCE_END/>

(Copy Probability: 3.7%)

<SENTENCE_START> { return ( obj == null ) ? 0 : obj . swig c ptr ; } <SENTENCE_END/>

Original Name touch,down

touch

<SENTENCE_START> { if ( disabled ) return false ; if ( dragging pointer != - 1 ) return false ; dragging pointer = pointer ; calculate position and value ( x , y ) ; return true ; } <SENTENCE_END/>

(Copy Probability: 3.4%)

<SENTENCE_START> { if ( disabled ) return false ; if ( dragging pointer != - 1 ) return false ; dragging pointer = pointer ; calculate position and value ( x , y ) ; return true ; } <SENTENCE_END/>

down

<SENTENCE_START> { if ( disabled ) return false ; if ( dragging pointer != - 1 ) return false ; dragging pointer = pointer ; calculate position and value ( x , y ) ; return true ; } <SENTENCE_END/>

(Copy Probability: 9.1%)

<SENTENCE_START> { if ( disabled ) return false ; if ( dragging pointer != - 1 ) return false ; dragging pointer = pointer ; calculate position and value ( x , y ) ; return true ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { if ( disabled ) return false ; if ( dragging pointer != - 1 ) return false ; dragging pointer = pointer ; calculate position and value ( x , y ) ; return true ; } <SENTENCE_END/>

(Copy Probability: 2.1%)

<SENTENCE_START> { if ( disabled ) return false ; if ( dragging pointer != - 1 ) return false ; dragging pointer = pointer ; calculate position and value ( x , y ) ; return true ; } <SENTENCE_END/>

Original Name touch,up

touch

<SENTENCE_START> { if ( pointer != dragging pointer ) return ; dragging pointer = - 1 ; if ( ! calculate position and value ( x , y ) ) { change event change event = pools . obtain ( change event . class ) ; fire ( change event ) ; pools . free ( change event ) ; } } <SENTENCE_END/>

(Copy Probability: 4.4%)

<SENTENCE_START> { if ( pointer != dragging pointer ) return ; dragging pointer = - 1 ; if ( ! calculate position and value ( x , y ) ) { change event change event = pools . obtain ( change event . class ) ; fire ( change event ) ; pools . free ( change event ) ; } } <SENTENCE_END/>

up

<SENTENCE_START> { if ( pointer != dragging pointer ) return ; dragging pointer = - 1 ; if ( ! calculate position and value ( x , y ) ) { change event change event = pools . obtain ( change event . class ) ; fire ( change event ) ; pools . free ( change event ) ; } } <SENTENCE_END/>

(Copy Probability: 19.0%)

<SENTENCE_START> { if ( pointer != dragging pointer ) return ; dragging pointer = - 1 ; if ( ! calculate position and value ( x , y ) ) { change event change event = pools . obtain ( change event . class ) ; fire ( change event ) ; pools . free ( change event ) ; } } <SENTENCE_END/>

%END%

<SENTENCE_START> { if ( pointer != dragging pointer ) return ; dragging pointer = - 1 ; if ( ! calculate position and value ( x , y ) ) { change event change event = pools . obtain ( change event . class ) ; fire ( change event ) ; pools . free ( change event ) ; } } <SENTENCE_END/>

(Copy Probability: 18.0%)

<SENTENCE_START> { if ( pointer != dragging pointer ) return ; dragging pointer = - 1 ; if ( ! calculate position and value ( x , y ) ) { change event change event = pools . obtain ( change event . class ) ; fire ( change event ) ; pools . free ( change event ) ; } } <SENTENCE_END/>

Original Name touch,dragged

touch

<SENTENCE_START> { calculate position and value ( x , y ) ; } <SENTENCE_END/>

(Copy Probability: 1.1%)

<SENTENCE_START> { calculate position and value ( x , y ) ; } <SENTENCE_END/>

dragged

<SENTENCE_START> { calculate position and value ( x , y ) ; } <SENTENCE_END/>

(Copy Probability: 66.4%)

<SENTENCE_START> { calculate position and value ( x , y ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { calculate position and value ( x , y ) ; } <SENTENCE_END/>

(Copy Probability: 7.9%)

<SENTENCE_START> { calculate position and value ( x , y ) ; } <SENTENCE_END/>

Original Name set,style

set

<SENTENCE_START> { if ( style == null ) throw new null pointer exception ( "style cannot be null" ) ; if ( ! ( style instanceof slider style ) ) throw new illegal argument exception ( "style must be a SliderStyle." ) ; super . %SELF% ( style ) ; } <SENTENCE_END/>

(Copy Probability: 2.6%)

<SENTENCE_START> { if ( style == null ) throw new null pointer exception ( "style cannot be null" ) ; if ( ! ( style instanceof slider style ) ) throw new illegal argument exception ( "style must be a SliderStyle." ) ; super . %SELF% ( style ) ; } <SENTENCE_END/>

style

<SENTENCE_START> { if ( style == null ) throw new null pointer exception ( "style cannot be null" ) ; if ( ! ( style instanceof slider style ) ) throw new illegal argument exception ( "style must be a SliderStyle." ) ; super . %SELF% ( style ) ; } <SENTENCE_END/>

(Copy Probability: 11.4%)

<SENTENCE_START> { if ( style == null ) throw new null pointer exception ( "style cannot be null" ) ; if ( ! ( style instanceof slider style ) ) throw new illegal argument exception ( "style must be a SliderStyle." ) ; super . %SELF% ( style ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { if ( style == null ) throw new null pointer exception ( "style cannot be null" ) ; if ( ! ( style instanceof slider style ) ) throw new illegal argument exception ( "style must be a SliderStyle." ) ; super . %SELF% ( style ) ; } <SENTENCE_END/>

(Copy Probability: 2.8%)

<SENTENCE_START> { if ( style == null ) throw new null pointer exception ( "style cannot be null" ) ; if ( ! ( style instanceof slider style ) ) throw new illegal argument exception ( "style must be a SliderStyle." ) ; super . %SELF% ( style ) ; } <SENTENCE_END/>

Original Name get,style

get

<SENTENCE_START> { return ( slider style ) super . %SELF% ( ) ; } <SENTENCE_END/>

(Copy Probability: 0.6%)

<SENTENCE_START> { return ( slider style ) super . %SELF% ( ) ; } <SENTENCE_END/>

style

<SENTENCE_START> { return ( slider style ) super . %SELF% ( ) ; } <SENTENCE_END/>

(Copy Probability: 0.5%)

<SENTENCE_START> { return ( slider style ) super . %SELF% ( ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return ( slider style ) super . %SELF% ( ) ; } <SENTENCE_END/>

(Copy Probability: 0.1%)

<SENTENCE_START> { return ( slider style ) super . %SELF% ( ) ; } <SENTENCE_END/>

Original Name calculate,position,and,value

calculate

<SENTENCE_START> { final slider style style = get style ( ) ; final drawable knob = get knob drawable ( ) ; final drawable bg = ( disabled && style . disabled background != null ) ? style . disabled background : style . background ; float value ; float old position = position ; final float min = get min value ( ) ; final float max = get max value ( ) ; if ( vertical ) { float height = get height ( ) - bg . get top height ( ) - bg . get bottom height ( ) ; float knob height = knob == null ? 0 : knob . get min height ( ) ; position = y - bg . get bottom height ( ) - knob height * 0.5f ; value = min + ( max - min ) * visual interpolation inverse . apply ( position / ( height - knob height ) ) ; position = math . max ( 0 , position ) ; position = math . min ( height - knob height , position ) ; } else { float width = get width ( ) - bg . get left width ( ) - bg . get right width ( ) ; float knob width = knob == null ? 0 : knob . get min width ( ) ; position = x - bg . get left width ( ) - knob width * 0.5f ; value = min + ( max - min ) * visual interpolation inverse . apply ( position / ( width - knob width ) ) ; position = math . max ( 0 , position ) ; position = math . min ( width - knob width , position ) ; } float old value = value ; boolean value set = set value ( value ) ; if ( value == old value ) position = old position ; return value set ; } <SENTENCE_END/>

(Copy Probability: 3.5%)

<SENTENCE_START> { final slider style style = get style ( ) ; final drawable knob = get knob drawable ( ) ; final drawable bg = ( disabled && style . disabled background != null ) ? style . disabled background : style . background ; float value ; float old position = position ; final float min = get min value ( ) ; final float max = get max value ( ) ; if ( vertical ) { float height = get height ( ) - bg . get top height ( ) - bg . get bottom height ( ) ; float knob height = knob == null ? 0 : knob . get min height ( ) ; position = y - bg . get bottom height ( ) - knob height * 0.5f ; value = min + ( max - min ) * visual interpolation inverse . apply ( position / ( height - knob height ) ) ; position = math . max ( 0 , position ) ; position = math . min ( height - knob height , position ) ; } else { float width = get width ( ) - bg . get left width ( ) - bg . get right width ( ) ; float knob width = knob == null ? 0 : knob . get min width ( ) ; position = x - bg . get left width ( ) - knob width * 0.5f ; value = min + ( max - min ) * visual interpolation inverse . apply ( position / ( width - knob width ) ) ; position = math . max ( 0 , position ) ; position = math . min ( width - knob width , position ) ; } float old value = value ; boolean value set = set value ( value ) ; if ( value == old value ) position = old position ; return value set ; } <SENTENCE_END/>

position

<SENTENCE_START> { final slider style style = get style ( ) ; final drawable knob = get knob drawable ( ) ; final drawable bg = ( disabled && style . disabled background != null ) ? style . disabled background : style . background ; float value ; float old position = position ; final float min = get min value ( ) ; final float max = get max value ( ) ; if ( vertical ) { float height = get height ( ) - bg . get top height ( ) - bg . get bottom height ( ) ; float knob height = knob == null ? 0 : knob . get min height ( ) ; position = y - bg . get bottom height ( ) - knob height * 0.5f ; value = min + ( max - min ) * visual interpolation inverse . apply ( position / ( height - knob height ) ) ; position = math . max ( 0 , position ) ; position = math . min ( height - knob height , position ) ; } else { float width = get width ( ) - bg . get left width ( ) - bg . get right width ( ) ; float knob width = knob == null ? 0 : knob . get min width ( ) ; position = x - bg . get left width ( ) - knob width * 0.5f ; value = min + ( max - min ) * visual interpolation inverse . apply ( position / ( width - knob width ) ) ; position = math . max ( 0 , position ) ; position = math . min ( width - knob width , position ) ; } float old value = value ; boolean value set = set value ( value ) ; if ( value == old value ) position = old position ; return value set ; } <SENTENCE_END/>

(Copy Probability: 25.2%)

<SENTENCE_START> { final slider style style = get style ( ) ; final drawable knob = get knob drawable ( ) ; final drawable bg = ( disabled && style . disabled background != null ) ? style . disabled background : style . background ; float value ; float old position = position ; final float min = get min value ( ) ; final float max = get max value ( ) ; if ( vertical ) { float height = get height ( ) - bg . get top height ( ) - bg . get bottom height ( ) ; float knob height = knob == null ? 0 : knob . get min height ( ) ; position = y - bg . get bottom height ( ) - knob height * 0.5f ; value = min + ( max - min ) * visual interpolation inverse . apply ( position / ( height - knob height ) ) ; position = math . max ( 0 , position ) ; position = math . min ( height - knob height , position ) ; } else { float width = get width ( ) - bg . get left width ( ) - bg . get right width ( ) ; float knob width = knob == null ? 0 : knob . get min width ( ) ; position = x - bg . get left width ( ) - knob width * 0.5f ; value = min + ( max - min ) * visual interpolation inverse . apply ( position / ( width - knob width ) ) ; position = math . max ( 0 , position ) ; position = math . min ( width - knob width , position ) ; } float old value = value ; boolean value set = set value ( value ) ; if ( value == old value ) position = old position ; return value set ; } <SENTENCE_END/>

and

<SENTENCE_START> { final slider style style = get style ( ) ; final drawable knob = get knob drawable ( ) ; final drawable bg = ( disabled && style . disabled background != null ) ? style . disabled background : style . background ; float value ; float old position = position ; final float min = get min value ( ) ; final float max = get max value ( ) ; if ( vertical ) { float height = get height ( ) - bg . get top height ( ) - bg . get bottom height ( ) ; float knob height = knob == null ? 0 : knob . get min height ( ) ; position = y - bg . get bottom height ( ) - knob height * 0.5f ; value = min + ( max - min ) * visual interpolation inverse . apply ( position / ( height - knob height ) ) ; position = math . max ( 0 , position ) ; position = math . min ( height - knob height , position ) ; } else { float width = get width ( ) - bg . get left width ( ) - bg . get right width ( ) ; float knob width = knob == null ? 0 : knob . get min width ( ) ; position = x - bg . get left width ( ) - knob width * 0.5f ; value = min + ( max - min ) * visual interpolation inverse . apply ( position / ( width - knob width ) ) ; position = math . max ( 0 , position ) ; position = math . min ( width - knob width , position ) ; } float old value = value ; boolean value set = set value ( value ) ; if ( value == old value ) position = old position ; return value set ; } <SENTENCE_END/>

(Copy Probability: 10.4%)

<SENTENCE_START> { final slider style style = get style ( ) ; final drawable knob = get knob drawable ( ) ; final drawable bg = ( disabled && style . disabled background != null ) ? style . disabled background : style . background ; float value ; float old position = position ; final float min = get min value ( ) ; final float max = get max value ( ) ; if ( vertical ) { float height = get height ( ) - bg . get top height ( ) - bg . get bottom height ( ) ; float knob height = knob == null ? 0 : knob . get min height ( ) ; position = y - bg . get bottom height ( ) - knob height * 0.5f ; value = min + ( max - min ) * visual interpolation inverse . apply ( position / ( height - knob height ) ) ; position = math . max ( 0 , position ) ; position = math . min ( height - knob height , position ) ; } else { float width = get width ( ) - bg . get left width ( ) - bg . get right width ( ) ; float knob width = knob == null ? 0 : knob . get min width ( ) ; position = x - bg . get left width ( ) - knob width * 0.5f ; value = min + ( max - min ) * visual interpolation inverse . apply ( position / ( width - knob width ) ) ; position = math . max ( 0 , position ) ; position = math . min ( width - knob width , position ) ; } float old value = value ; boolean value set = set value ( value ) ; if ( value == old value ) position = old position ; return value set ; } <SENTENCE_END/>

value

<SENTENCE_START> { final slider style style = get style ( ) ; final drawable knob = get knob drawable ( ) ; final drawable bg = ( disabled && style . disabled background != null ) ? style . disabled background : style . background ; float value ; float old position = position ; final float min = get min value ( ) ; final float max = get max value ( ) ; if ( vertical ) { float height = get height ( ) - bg . get top height ( ) - bg . get bottom height ( ) ; float knob height = knob == null ? 0 : knob . get min height ( ) ; position = y - bg . get bottom height ( ) - knob height * 0.5f ; value = min + ( max - min ) * visual interpolation inverse . apply ( position / ( height - knob height ) ) ; position = math . max ( 0 , position ) ; position = math . min ( height - knob height , position ) ; } else { float width = get width ( ) - bg . get left width ( ) - bg . get right width ( ) ; float knob width = knob == null ? 0 : knob . get min width ( ) ; position = x - bg . get left width ( ) - knob width * 0.5f ; value = min + ( max - min ) * visual interpolation inverse . apply ( position / ( width - knob width ) ) ; position = math . max ( 0 , position ) ; position = math . min ( width - knob width , position ) ; } float old value = value ; boolean value set = set value ( value ) ; if ( value == old value ) position = old position ; return value set ; } <SENTENCE_END/>

(Copy Probability: 4.2%)

<SENTENCE_START> { final slider style style = get style ( ) ; final drawable knob = get knob drawable ( ) ; final drawable bg = ( disabled && style . disabled background != null ) ? style . disabled background : style . background ; float value ; float old position = position ; final float min = get min value ( ) ; final float max = get max value ( ) ; if ( vertical ) { float height = get height ( ) - bg . get top height ( ) - bg . get bottom height ( ) ; float knob height = knob == null ? 0 : knob . get min height ( ) ; position = y - bg . get bottom height ( ) - knob height * 0.5f ; value = min + ( max - min ) * visual interpolation inverse . apply ( position / ( height - knob height ) ) ; position = math . max ( 0 , position ) ; position = math . min ( height - knob height , position ) ; } else { float width = get width ( ) - bg . get left width ( ) - bg . get right width ( ) ; float knob width = knob == null ? 0 : knob . get min width ( ) ; position = x - bg . get left width ( ) - knob width * 0.5f ; value = min + ( max - min ) * visual interpolation inverse . apply ( position / ( width - knob width ) ) ; position = math . max ( 0 , position ) ; position = math . min ( width - knob width , position ) ; } float old value = value ; boolean value set = set value ( value ) ; if ( value == old value ) position = old position ; return value set ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { final slider style style = get style ( ) ; final drawable knob = get knob drawable ( ) ; final drawable bg = ( disabled && style . disabled background != null ) ? style . disabled background : style . background ; float value ; float old position = position ; final float min = get min value ( ) ; final float max = get max value ( ) ; if ( vertical ) { float height = get height ( ) - bg . get top height ( ) - bg . get bottom height ( ) ; float knob height = knob == null ? 0 : knob . get min height ( ) ; position = y - bg . get bottom height ( ) - knob height * 0.5f ; value = min + ( max - min ) * visual interpolation inverse . apply ( position / ( height - knob height ) ) ; position = math . max ( 0 , position ) ; position = math . min ( height - knob height , position ) ; } else { float width = get width ( ) - bg . get left width ( ) - bg . get right width ( ) ; float knob width = knob == null ? 0 : knob . get min width ( ) ; position = x - bg . get left width ( ) - knob width * 0.5f ; value = min + ( max - min ) * visual interpolation inverse . apply ( position / ( width - knob width ) ) ; position = math . max ( 0 , position ) ; position = math . min ( width - knob width , position ) ; } float old value = value ; boolean value set = set value ( value ) ; if ( value == old value ) position = old position ; return value set ; } <SENTENCE_END/>

(Copy Probability: 3.8%)

<SENTENCE_START> { final slider style style = get style ( ) ; final drawable knob = get knob drawable ( ) ; final drawable bg = ( disabled && style . disabled background != null ) ? style . disabled background : style . background ; float value ; float old position = position ; final float min = get min value ( ) ; final float max = get max value ( ) ; if ( vertical ) { float height = get height ( ) - bg . get top height ( ) - bg . get bottom height ( ) ; float knob height = knob == null ? 0 : knob . get min height ( ) ; position = y - bg . get bottom height ( ) - knob height * 0.5f ; value = min + ( max - min ) * visual interpolation inverse . apply ( position / ( height - knob height ) ) ; position = math . max ( 0 , position ) ; position = math . min ( height - knob height , position ) ; } else { float width = get width ( ) - bg . get left width ( ) - bg . get right width ( ) ; float knob width = knob == null ? 0 : knob . get min width ( ) ; position = x - bg . get left width ( ) - knob width * 0.5f ; value = min + ( max - min ) * visual interpolation inverse . apply ( position / ( width - knob width ) ) ; position = math . max ( 0 , position ) ; position = math . min ( width - knob width , position ) ; } float old value = value ; boolean value set = set value ( value ) ; if ( value == old value ) position = old position ; return value set ; } <SENTENCE_END/>

Original Name is,dragging

is

<SENTENCE_START> { return dragging pointer != - 1 ; } <SENTENCE_END/>

(Copy Probability: 0.6%)

<SENTENCE_START> { return dragging pointer != - 1 ; } <SENTENCE_END/>

dragging

<SENTENCE_START> { return dragging pointer != - 1 ; } <SENTENCE_END/>

(Copy Probability: 6.2%)

<SENTENCE_START> { return dragging pointer != - 1 ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return dragging pointer != - 1 ; } <SENTENCE_END/>

(Copy Probability: 6.8%)

<SENTENCE_START> { return dragging pointer != - 1 ; } <SENTENCE_END/>

Original Name set,visual,interpolation,inverse

set

<SENTENCE_START> { this . visual interpolation inverse = interpolation ; } <SENTENCE_END/>

(Copy Probability: 1.9%)

<SENTENCE_START> { this . visual interpolation inverse = interpolation ; } <SENTENCE_END/>

visual

<SENTENCE_START> { this . visual interpolation inverse = interpolation ; } <SENTENCE_END/>

(Copy Probability: 98.1%)

<SENTENCE_START> { this . visual interpolation inverse = interpolation ; } <SENTENCE_END/>

interpolation

<SENTENCE_START> { this . visual interpolation inverse = interpolation ; } <SENTENCE_END/>

(Copy Probability: 98.4%)

<SENTENCE_START> { this . visual interpolation inverse = interpolation ; } <SENTENCE_END/>

inverse

<SENTENCE_START> { this . visual interpolation inverse = interpolation ; } <SENTENCE_END/>

(Copy Probability: 40.8%)

<SENTENCE_START> { this . visual interpolation inverse = interpolation ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { this . visual interpolation inverse = interpolation ; } <SENTENCE_END/>

(Copy Probability: 3.9%)

<SENTENCE_START> { this . visual interpolation inverse = interpolation ; } <SENTENCE_END/>

Original Name get,c,ptr

get

<SENTENCE_START> { return ( obj == null ) ? 0 : obj . swig c ptr ; } <SENTENCE_END/>

(Copy Probability: 1.5%)

<SENTENCE_START> { return ( obj == null ) ? 0 : obj . swig c ptr ; } <SENTENCE_END/>

c

<SENTENCE_START> { return ( obj == null ) ? 0 : obj . swig c ptr ; } <SENTENCE_END/>

(Copy Probability: 99.7%)

<SENTENCE_START> { return ( obj == null ) ? 0 : obj . swig c ptr ; } <SENTENCE_END/>

ptr

<SENTENCE_START> { return ( obj == null ) ? 0 : obj . swig c ptr ; } <SENTENCE_END/>

(Copy Probability: 99.8%)

<SENTENCE_START> { return ( obj == null ) ? 0 : obj . swig c ptr ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return ( obj == null ) ? 0 : obj . swig c ptr ; } <SENTENCE_END/>

(Copy Probability: 3.7%)

<SENTENCE_START> { return ( obj == null ) ? 0 : obj . swig c ptr ; } <SENTENCE_END/>

Original Name swig,director,disconnect

swig

<SENTENCE_START> { swig c mem own = false ; delete ( ) ; } <SENTENCE_END/>

(Copy Probability: 1.5%)

<SENTENCE_START> { swig c mem own = false ; delete ( ) ; } <SENTENCE_END/>

director

<SENTENCE_START> { swig c mem own = false ; delete ( ) ; } <SENTENCE_END/>

(Copy Probability: 0.9%)

<SENTENCE_START> { swig c mem own = false ; delete ( ) ; } <SENTENCE_END/>

disconnect

<SENTENCE_START> { swig c mem own = false ; delete ( ) ; } <SENTENCE_END/>

(Copy Probability: 0.2%)

<SENTENCE_START> { swig c mem own = false ; delete ( ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { swig c mem own = false ; delete ( ) ; } <SENTENCE_END/>

(Copy Probability: 2.3%)

<SENTENCE_START> { swig c mem own = false ; delete ( ) ; } <SENTENCE_END/>

Original Name swig,release,ownership

swig

<SENTENCE_START> { swig c mem own = false ; collision jni . bt overlap callback change ownership ( this , swig c ptr , false ) ; } <SENTENCE_END/>

(Copy Probability: 2.8%)

<SENTENCE_START> { swig c mem own = false ; collision jni . bt overlap callback change ownership ( this , swig c ptr , false ) ; } <SENTENCE_END/>

release

<SENTENCE_START> { swig c mem own = false ; collision jni . bt overlap callback change ownership ( this , swig c ptr , false ) ; } <SENTENCE_END/>

(Copy Probability: 12.3%)

<SENTENCE_START> { swig c mem own = false ; collision jni . bt overlap callback change ownership ( this , swig c ptr , false ) ; } <SENTENCE_END/>

ownership

<SENTENCE_START> { swig c mem own = false ; collision jni . bt overlap callback change ownership ( this , swig c ptr , false ) ; } <SENTENCE_END/>

(Copy Probability: 62.2%)

<SENTENCE_START> { swig c mem own = false ; collision jni . bt overlap callback change ownership ( this , swig c ptr , false ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { swig c mem own = false ; collision jni . bt overlap callback change ownership ( this , swig c ptr , false ) ; } <SENTENCE_END/>

(Copy Probability: 6.7%)

<SENTENCE_START> { swig c mem own = false ; collision jni . bt overlap callback change ownership ( this , swig c ptr , false ) ; } <SENTENCE_END/>

Original Name swig,take,ownership

swig

<SENTENCE_START> { swig c mem own = true ; collision jni . bt overlap callback change ownership ( this , swig c ptr , true ) ; } <SENTENCE_END/>

(Copy Probability: 3.4%)

<SENTENCE_START> { swig c mem own = true ; collision jni . bt overlap callback change ownership ( this , swig c ptr , true ) ; } <SENTENCE_END/>

take

<SENTENCE_START> { swig c mem own = true ; collision jni . bt overlap callback change ownership ( this , swig c ptr , true ) ; } <SENTENCE_END/>

(Copy Probability: 13.7%)

<SENTENCE_START> { swig c mem own = true ; collision jni . bt overlap callback change ownership ( this , swig c ptr , true ) ; } <SENTENCE_END/>

ownership

<SENTENCE_START> { swig c mem own = true ; collision jni . bt overlap callback change ownership ( this , swig c ptr , true ) ; } <SENTENCE_END/>

(Copy Probability: 67.9%)

<SENTENCE_START> { swig c mem own = true ; collision jni . bt overlap callback change ownership ( this , swig c ptr , true ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { swig c mem own = true ; collision jni . bt overlap callback change ownership ( this , swig c ptr , true ) ; } <SENTENCE_END/>

(Copy Probability: 5.2%)

<SENTENCE_START> { swig c mem own = true ; collision jni . bt overlap callback change ownership ( this , swig c ptr , true ) ; } <SENTENCE_END/>

Original Name process,overlap

process

<SENTENCE_START> { return collision jni . bt overlap callback process overlap ( swig c ptr , this , pair ) ; } <SENTENCE_END/>

(Copy Probability: 18.0%)

<SENTENCE_START> { return collision jni . bt overlap callback process overlap ( swig c ptr , this , pair ) ; } <SENTENCE_END/>

overlap

<SENTENCE_START> { return collision jni . bt overlap callback process overlap ( swig c ptr , this , pair ) ; } <SENTENCE_END/>

(Copy Probability: 95.6%)

<SENTENCE_START> { return collision jni . bt overlap callback process overlap ( swig c ptr , this , pair ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return collision jni . bt overlap callback process overlap ( swig c ptr , this , pair ) ; } <SENTENCE_END/>

(Copy Probability: 1.0%)

<SENTENCE_START> { return collision jni . bt overlap callback process overlap ( swig c ptr , this , pair ) ; } <SENTENCE_END/>

Original Name sort

sort

<SENTENCE_START> { if ( comparable tim sort == null ) comparable tim sort = new comparable tim sort ( ) ; comparable tim sort . do sort ( ( object [ ] ) a . items , 0 , a . size ) ; } <SENTENCE_END/>

(Copy Probability: 1.6%)

<SENTENCE_START> { if ( comparable tim sort == null ) comparable tim sort = new comparable tim sort ( ) ; comparable tim sort . do sort ( ( object [ ] ) a . items , 0 , a . size ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { if ( comparable tim sort == null ) comparable tim sort = new comparable tim sort ( ) ; comparable tim sort . do sort ( ( object [ ] ) a . items , 0 , a . size ) ; } <SENTENCE_END/>

(Copy Probability: 2.0%)

<SENTENCE_START> { if ( comparable tim sort == null ) comparable tim sort = new comparable tim sort ( ) ; comparable tim sort . do sort ( ( object [ ] ) a . items , 0 , a . size ) ; } <SENTENCE_END/>

Original Name sort

sort

<SENTENCE_START> { if ( comparable tim sort == null ) comparable tim sort = new comparable tim sort ( ) ; comparable tim sort . do sort ( a , 0 , a . length ) ; } <SENTENCE_END/>

(Copy Probability: 1.7%)

<SENTENCE_START> { if ( comparable tim sort == null ) comparable tim sort = new comparable tim sort ( ) ; comparable tim sort . do sort ( a , 0 , a . length ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { if ( comparable tim sort == null ) comparable tim sort = new comparable tim sort ( ) ; comparable tim sort . do sort ( a , 0 , a . length ) ; } <SENTENCE_END/>

(Copy Probability: 2.0%)

<SENTENCE_START> { if ( comparable tim sort == null ) comparable tim sort = new comparable tim sort ( ) ; comparable tim sort . do sort ( a , 0 , a . length ) ; } <SENTENCE_END/>

Original Name sort

sort

<SENTENCE_START> { if ( comparable tim sort == null ) comparable tim sort = new comparable tim sort ( ) ; comparable tim sort . do sort ( a , from index , to index ) ; } <SENTENCE_END/>

(Copy Probability: 1.8%)

<SENTENCE_START> { if ( comparable tim sort == null ) comparable tim sort = new comparable tim sort ( ) ; comparable tim sort . do sort ( a , from index , to index ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { if ( comparable tim sort == null ) comparable tim sort = new comparable tim sort ( ) ; comparable tim sort . do sort ( a , from index , to index ) ; } <SENTENCE_END/>

(Copy Probability: 1.9%)

<SENTENCE_START> { if ( comparable tim sort == null ) comparable tim sort = new comparable tim sort ( ) ; comparable tim sort . do sort ( a , from index , to index ) ; } <SENTENCE_END/>

Original Name sort

sort

<SENTENCE_START> { if ( tim sort == null ) tim sort = new tim sort ( ) ; tim sort . do sort ( ( object [ ] ) a . items , ( comparator ) c , 0 , a . size ) ; } <SENTENCE_END/>

(Copy Probability: 2.2%)

<SENTENCE_START> { if ( tim sort == null ) tim sort = new tim sort ( ) ; tim sort . do sort ( ( object [ ] ) a . items , ( comparator ) c , 0 , a . size ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { if ( tim sort == null ) tim sort = new tim sort ( ) ; tim sort . do sort ( ( object [ ] ) a . items , ( comparator ) c , 0 , a . size ) ; } <SENTENCE_END/>

(Copy Probability: 2.0%)

<SENTENCE_START> { if ( tim sort == null ) tim sort = new tim sort ( ) ; tim sort . do sort ( ( object [ ] ) a . items , ( comparator ) c , 0 , a . size ) ; } <SENTENCE_END/>

Original Name sort

sort

<SENTENCE_START> { if ( tim sort == null ) tim sort = new tim sort ( ) ; tim sort . do sort ( a , c , 0 , a . length ) ; } <SENTENCE_END/>

(Copy Probability: 2.2%)

<SENTENCE_START> { if ( tim sort == null ) tim sort = new tim sort ( ) ; tim sort . do sort ( a , c , 0 , a . length ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { if ( tim sort == null ) tim sort = new tim sort ( ) ; tim sort . do sort ( a , c , 0 , a . length ) ; } <SENTENCE_END/>

(Copy Probability: 2.0%)

<SENTENCE_START> { if ( tim sort == null ) tim sort = new tim sort ( ) ; tim sort . do sort ( a , c , 0 , a . length ) ; } <SENTENCE_END/>

Original Name sort

sort

<SENTENCE_START> { if ( tim sort == null ) tim sort = new tim sort ( ) ; tim sort . do sort ( a , c , from index , to index ) ; } <SENTENCE_END/>

(Copy Probability: 2.4%)

<SENTENCE_START> { if ( tim sort == null ) tim sort = new tim sort ( ) ; tim sort . do sort ( a , c , from index , to index ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { if ( tim sort == null ) tim sort = new tim sort ( ) ; tim sort . do sort ( a , c , from index , to index ) ; } <SENTENCE_END/>

(Copy Probability: 1.9%)

<SENTENCE_START> { if ( tim sort == null ) tim sort = new tim sort ( ) ; tim sort . do sort ( a , c , from index , to index ) ; } <SENTENCE_END/>

Original Name instance

instance

<SENTENCE_START> { if ( %SELF% == null ) %SELF% = new sort ( ) ; return %SELF% ; } <SENTENCE_END/>

(Copy Probability: 0.5%)

<SENTENCE_START> { if ( %SELF% == null ) %SELF% = new sort ( ) ; return %SELF% ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { if ( %SELF% == null ) %SELF% = new sort ( ) ; return %SELF% ; } <SENTENCE_END/>

(Copy Probability: 0.4%)

<SENTENCE_START> { if ( %SELF% == null ) %SELF% = new sort ( ) ; return %SELF% ; } <SENTENCE_END/>

Original Name get,joint,angle

get

<SENTENCE_START> { return jni get joint angle ( addr ) ; } <SENTENCE_END/>

(Copy Probability: 1.9%)

<SENTENCE_START> { return jni get joint angle ( addr ) ; } <SENTENCE_END/>

joint

<SENTENCE_START> { return jni get joint angle ( addr ) ; } <SENTENCE_END/>

(Copy Probability: 99.8%)

<SENTENCE_START> { return jni get joint angle ( addr ) ; } <SENTENCE_END/>

angle

<SENTENCE_START> { return jni get joint angle ( addr ) ; } <SENTENCE_END/>

(Copy Probability: 95.6%)

<SENTENCE_START> { return jni get joint angle ( addr ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return jni get joint angle ( addr ) ; } <SENTENCE_END/>

(Copy Probability: 1.7%)

<SENTENCE_START> { return jni get joint angle ( addr ) ; } <SENTENCE_END/>

Original Name get,joint,speed

get

<SENTENCE_START> { return jni get joint speed ( addr ) ; } <SENTENCE_END/>

(Copy Probability: 1.8%)

<SENTENCE_START> { return jni get joint speed ( addr ) ; } <SENTENCE_END/>

joint

<SENTENCE_START> { return jni get joint speed ( addr ) ; } <SENTENCE_END/>

(Copy Probability: 99.9%)

<SENTENCE_START> { return jni get joint speed ( addr ) ; } <SENTENCE_END/>

speed

<SENTENCE_START> { return jni get joint speed ( addr ) ; } <SENTENCE_END/>

(Copy Probability: 99.1%)

<SENTENCE_START> { return jni get joint speed ( addr ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return jni get joint speed ( addr ) ; } <SENTENCE_END/>

(Copy Probability: 3.4%)

<SENTENCE_START> { return jni get joint speed ( addr ) ; } <SENTENCE_END/>

Original Name is,limit,enabled

is

<SENTENCE_START> { return jni is limit enabled ( addr ) ; } <SENTENCE_END/>

(Copy Probability: 2.5%)

<SENTENCE_START> { return jni is limit enabled ( addr ) ; } <SENTENCE_END/>

limit

<SENTENCE_START> { return jni is limit enabled ( addr ) ; } <SENTENCE_END/>

(Copy Probability: 99.9%)

<SENTENCE_START> { return jni is limit enabled ( addr ) ; } <SENTENCE_END/>

enabled

<SENTENCE_START> { return jni is limit enabled ( addr ) ; } <SENTENCE_END/>

(Copy Probability: 92.0%)

<SENTENCE_START> { return jni is limit enabled ( addr ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return jni is limit enabled ( addr ) ; } <SENTENCE_END/>

(Copy Probability: 1.8%)

<SENTENCE_START> { return jni is limit enabled ( addr ) ; } <SENTENCE_END/>

Original Name enable,limit

enable

<SENTENCE_START> { jni enable limit ( addr , flag ) ; } <SENTENCE_END/>

(Copy Probability: 7.7%)

<SENTENCE_START> { jni enable limit ( addr , flag ) ; } <SENTENCE_END/>

limit

<SENTENCE_START> { jni enable limit ( addr , flag ) ; } <SENTENCE_END/>

(Copy Probability: 97.7%)

<SENTENCE_START> { jni enable limit ( addr , flag ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { jni enable limit ( addr , flag ) ; } <SENTENCE_END/>

(Copy Probability: 1.0%)

<SENTENCE_START> { jni enable limit ( addr , flag ) ; } <SENTENCE_END/>

Original Name get,lower,limit

get

<SENTENCE_START> { return jni get lower limit ( addr ) ; } <SENTENCE_END/>

(Copy Probability: 2.2%)

<SENTENCE_START> { return jni get lower limit ( addr ) ; } <SENTENCE_END/>

lower

<SENTENCE_START> { return jni get lower limit ( addr ) ; } <SENTENCE_END/>

(Copy Probability: 99.8%)

<SENTENCE_START> { return jni get lower limit ( addr ) ; } <SENTENCE_END/>

limit

<SENTENCE_START> { return jni get lower limit ( addr ) ; } <SENTENCE_END/>

(Copy Probability: 99.4%)

<SENTENCE_START> { return jni get lower limit ( addr ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return jni get lower limit ( addr ) ; } <SENTENCE_END/>

(Copy Probability: 2.3%)

<SENTENCE_START> { return jni get lower limit ( addr ) ; } <SENTENCE_END/>

Original Name get,upper,limit

get

<SENTENCE_START> { return jni get upper limit ( addr ) ; } <SENTENCE_END/>

(Copy Probability: 2.4%)

<SENTENCE_START> { return jni get upper limit ( addr ) ; } <SENTENCE_END/>

upper

<SENTENCE_START> { return jni get upper limit ( addr ) ; } <SENTENCE_END/>

(Copy Probability: 99.8%)

<SENTENCE_START> { return jni get upper limit ( addr ) ; } <SENTENCE_END/>

limit

<SENTENCE_START> { return jni get upper limit ( addr ) ; } <SENTENCE_END/>

(Copy Probability: 99.4%)

<SENTENCE_START> { return jni get upper limit ( addr ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return jni get upper limit ( addr ) ; } <SENTENCE_END/>

(Copy Probability: 2.6%)

<SENTENCE_START> { return jni get upper limit ( addr ) ; } <SENTENCE_END/>

Original Name set,limits

set

<SENTENCE_START> { jni set limits ( addr , lower , upper ) ; } <SENTENCE_END/>

(Copy Probability: 3.0%)

<SENTENCE_START> { jni set limits ( addr , lower , upper ) ; } <SENTENCE_END/>

limits

<SENTENCE_START> { jni set limits ( addr , lower , upper ) ; } <SENTENCE_END/>

(Copy Probability: 98.0%)

<SENTENCE_START> { jni set limits ( addr , lower , upper ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { jni set limits ( addr , lower , upper ) ; } <SENTENCE_END/>

(Copy Probability: 1.3%)

<SENTENCE_START> { jni set limits ( addr , lower , upper ) ; } <SENTENCE_END/>

Original Name is,motor,enabled

is

<SENTENCE_START> { return jni is motor enabled ( addr ) ; } <SENTENCE_END/>

(Copy Probability: 2.4%)

<SENTENCE_START> { return jni is motor enabled ( addr ) ; } <SENTENCE_END/>

motor

<SENTENCE_START> { return jni is motor enabled ( addr ) ; } <SENTENCE_END/>

(Copy Probability: 99.9%)

<SENTENCE_START> { return jni is motor enabled ( addr ) ; } <SENTENCE_END/>

enabled

<SENTENCE_START> { return jni is motor enabled ( addr ) ; } <SENTENCE_END/>

(Copy Probability: 96.6%)

<SENTENCE_START> { return jni is motor enabled ( addr ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return jni is motor enabled ( addr ) ; } <SENTENCE_END/>

(Copy Probability: 2.3%)

<SENTENCE_START> { return jni is motor enabled ( addr ) ; } <SENTENCE_END/>

Original Name enable,motor

enable

<SENTENCE_START> { jni enable motor ( addr , flag ) ; } <SENTENCE_END/>

(Copy Probability: 7.0%)

<SENTENCE_START> { jni enable motor ( addr , flag ) ; } <SENTENCE_END/>

motor

<SENTENCE_START> { jni enable motor ( addr , flag ) ; } <SENTENCE_END/>

(Copy Probability: 99.0%)

<SENTENCE_START> { jni enable motor ( addr , flag ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { jni enable motor ( addr , flag ) ; } <SENTENCE_END/>

(Copy Probability: 1.2%)

<SENTENCE_START> { jni enable motor ( addr , flag ) ; } <SENTENCE_END/>

Original Name set,motor,speed

set

<SENTENCE_START> { jni set motor speed ( addr , speed ) ; } <SENTENCE_END/>

(Copy Probability: 2.1%)

<SENTENCE_START> { jni set motor speed ( addr , speed ) ; } <SENTENCE_END/>

motor

<SENTENCE_START> { jni set motor speed ( addr , speed ) ; } <SENTENCE_END/>

(Copy Probability: 99.7%)

<SENTENCE_START> { jni set motor speed ( addr , speed ) ; } <SENTENCE_END/>

speed

<SENTENCE_START> { jni set motor speed ( addr , speed ) ; } <SENTENCE_END/>

(Copy Probability: 99.5%)

<SENTENCE_START> { jni set motor speed ( addr , speed ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { jni set motor speed ( addr , speed ) ; } <SENTENCE_END/>

(Copy Probability: 2.9%)

<SENTENCE_START> { jni set motor speed ( addr , speed ) ; } <SENTENCE_END/>

Original Name get,motor,speed

get

<SENTENCE_START> { return jni get motor speed ( addr ) ; } <SENTENCE_END/>

(Copy Probability: 2.2%)

<SENTENCE_START> { return jni get motor speed ( addr ) ; } <SENTENCE_END/>

motor

<SENTENCE_START> { return jni get motor speed ( addr ) ; } <SENTENCE_END/>

(Copy Probability: 99.9%)

<SENTENCE_START> { return jni get motor speed ( addr ) ; } <SENTENCE_END/>

speed

<SENTENCE_START> { return jni get motor speed ( addr ) ; } <SENTENCE_END/>

(Copy Probability: 99.7%)

<SENTENCE_START> { return jni get motor speed ( addr ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return jni get motor speed ( addr ) ; } <SENTENCE_END/>

(Copy Probability: 2.9%)

<SENTENCE_START> { return jni get motor speed ( addr ) ; } <SENTENCE_END/>

Original Name set,max,motor,torque

set

<SENTENCE_START> { jni set max motor torque ( addr , torque ) ; } <SENTENCE_END/>

(Copy Probability: 1.7%)

<SENTENCE_START> { jni set max motor torque ( addr , torque ) ; } <SENTENCE_END/>

max

<SENTENCE_START> { jni set max motor torque ( addr , torque ) ; } <SENTENCE_END/>

(Copy Probability: 99.8%)

<SENTENCE_START> { jni set max motor torque ( addr , torque ) ; } <SENTENCE_END/>

motor

<SENTENCE_START> { jni set max motor torque ( addr , torque ) ; } <SENTENCE_END/>

(Copy Probability: 100.0%)

<SENTENCE_START> { jni set max motor torque ( addr , torque ) ; } <SENTENCE_END/>

torque

<SENTENCE_START> { jni set max motor torque ( addr , torque ) ; } <SENTENCE_END/>

(Copy Probability: 85.9%)

<SENTENCE_START> { jni set max motor torque ( addr , torque ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { jni set max motor torque ( addr , torque ) ; } <SENTENCE_END/>

(Copy Probability: 5.1%)

<SENTENCE_START> { jni set max motor torque ( addr , torque ) ; } <SENTENCE_END/>

Original Name get,motor,torque

get

<SENTENCE_START> { return jni get motor torque ( addr , inv dt ) ; } <SENTENCE_END/>

(Copy Probability: 2.4%)

<SENTENCE_START> { return jni get motor torque ( addr , inv dt ) ; } <SENTENCE_END/>

motor

<SENTENCE_START> { return jni get motor torque ( addr , inv dt ) ; } <SENTENCE_END/>

(Copy Probability: 99.8%)

<SENTENCE_START> { return jni get motor torque ( addr , inv dt ) ; } <SENTENCE_END/>

torque

<SENTENCE_START> { return jni get motor torque ( addr , inv dt ) ; } <SENTENCE_END/>

(Copy Probability: 99.7%)

<SENTENCE_START> { return jni get motor torque ( addr , inv dt ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return jni get motor torque ( addr , inv dt ) ; } <SENTENCE_END/>

(Copy Probability: 3.2%)

<SENTENCE_START> { return jni get motor torque ( addr , inv dt ) ; } <SENTENCE_END/>

Original Name get,local,anchor,a

get

<SENTENCE_START> { jni get local anchor a ( addr , tmp ) ; local anchor a . set ( tmp [ 0 ] , tmp [ 1 ] ) ; return local anchor a ; } <SENTENCE_END/>

(Copy Probability: 6.5%)

<SENTENCE_START> { jni get local anchor a ( addr , tmp ) ; local anchor a . set ( tmp [ 0 ] , tmp [ 1 ] ) ; return local anchor a ; } <SENTENCE_END/>

local

<SENTENCE_START> { jni get local anchor a ( addr , tmp ) ; local anchor a . set ( tmp [ 0 ] , tmp [ 1 ] ) ; return local anchor a ; } <SENTENCE_END/>

(Copy Probability: 99.5%)

<SENTENCE_START> { jni get local anchor a ( addr , tmp ) ; local anchor a . set ( tmp [ 0 ] , tmp [ 1 ] ) ; return local anchor a ; } <SENTENCE_END/>

anchor

<SENTENCE_START> { jni get local anchor a ( addr , tmp ) ; local anchor a . set ( tmp [ 0 ] , tmp [ 1 ] ) ; return local anchor a ; } <SENTENCE_END/>

(Copy Probability: 99.9%)

<SENTENCE_START> { jni get local anchor a ( addr , tmp ) ; local anchor a . set ( tmp [ 0 ] , tmp [ 1 ] ) ; return local anchor a ; } <SENTENCE_END/>

a

<SENTENCE_START> { jni get local anchor a ( addr , tmp ) ; local anchor a . set ( tmp [ 0 ] , tmp [ 1 ] ) ; return local anchor a ; } <SENTENCE_END/>

(Copy Probability: 85.3%)

<SENTENCE_START> { jni get local anchor a ( addr , tmp ) ; local anchor a . set ( tmp [ 0 ] , tmp [ 1 ] ) ; return local anchor a ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { jni get local anchor a ( addr , tmp ) ; local anchor a . set ( tmp [ 0 ] , tmp [ 1 ] ) ; return local anchor a ; } <SENTENCE_END/>

(Copy Probability: 6.2%)

<SENTENCE_START> { jni get local anchor a ( addr , tmp ) ; local anchor a . set ( tmp [ 0 ] , tmp [ 1 ] ) ; return local anchor a ; } <SENTENCE_END/>

Original Name get,local,anchor,b

get

<SENTENCE_START> { jni get local anchor b ( addr , tmp ) ; local anchor b . set ( tmp [ 0 ] , tmp [ 1 ] ) ; return local anchor b ; } <SENTENCE_END/>

(Copy Probability: 5.5%)

<SENTENCE_START> { jni get local anchor b ( addr , tmp ) ; local anchor b . set ( tmp [ 0 ] , tmp [ 1 ] ) ; return local anchor b ; } <SENTENCE_END/>

local

<SENTENCE_START> { jni get local anchor b ( addr , tmp ) ; local anchor b . set ( tmp [ 0 ] , tmp [ 1 ] ) ; return local anchor b ; } <SENTENCE_END/>

(Copy Probability: 99.6%)

<SENTENCE_START> { jni get local anchor b ( addr , tmp ) ; local anchor b . set ( tmp [ 0 ] , tmp [ 1 ] ) ; return local anchor b ; } <SENTENCE_END/>

anchor

<SENTENCE_START> { jni get local anchor b ( addr , tmp ) ; local anchor b . set ( tmp [ 0 ] , tmp [ 1 ] ) ; return local anchor b ; } <SENTENCE_END/>

(Copy Probability: 99.9%)

<SENTENCE_START> { jni get local anchor b ( addr , tmp ) ; local anchor b . set ( tmp [ 0 ] , tmp [ 1 ] ) ; return local anchor b ; } <SENTENCE_END/>

b

<SENTENCE_START> { jni get local anchor b ( addr , tmp ) ; local anchor b . set ( tmp [ 0 ] , tmp [ 1 ] ) ; return local anchor b ; } <SENTENCE_END/>

(Copy Probability: 78.3%)

<SENTENCE_START> { jni get local anchor b ( addr , tmp ) ; local anchor b . set ( tmp [ 0 ] , tmp [ 1 ] ) ; return local anchor b ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { jni get local anchor b ( addr , tmp ) ; local anchor b . set ( tmp [ 0 ] , tmp [ 1 ] ) ; return local anchor b ; } <SENTENCE_END/>

(Copy Probability: 4.7%)

<SENTENCE_START> { jni get local anchor b ( addr , tmp ) ; local anchor b . set ( tmp [ 0 ] , tmp [ 1 ] ) ; return local anchor b ; } <SENTENCE_END/>

Original Name get,reference,angle

get

<SENTENCE_START> { return jni get reference angle ( addr ) ; } <SENTENCE_END/>

(Copy Probability: 2.3%)

<SENTENCE_START> { return jni get reference angle ( addr ) ; } <SENTENCE_END/>

reference

<SENTENCE_START> { return jni get reference angle ( addr ) ; } <SENTENCE_END/>

(Copy Probability: 99.9%)

<SENTENCE_START> { return jni get reference angle ( addr ) ; } <SENTENCE_END/>

angle

<SENTENCE_START> { return jni get reference angle ( addr ) ; } <SENTENCE_END/>

(Copy Probability: 99.0%)

<SENTENCE_START> { return jni get reference angle ( addr ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return jni get reference angle ( addr ) ; } <SENTENCE_END/>

(Copy Probability: 3.5%)

<SENTENCE_START> { return jni get reference angle ( addr ) ; } <SENTENCE_END/>

Original Name get,max,motor,torque

get

<SENTENCE_START> { return jni get max motor torque ( addr ) ; } <SENTENCE_END/>

(Copy Probability: 1.8%)

<SENTENCE_START> { return jni get max motor torque ( addr ) ; } <SENTENCE_END/>

max

<SENTENCE_START> { return jni get max motor torque ( addr ) ; } <SENTENCE_END/>

(Copy Probability: 99.9%)

<SENTENCE_START> { return jni get max motor torque ( addr ) ; } <SENTENCE_END/>

motor

<SENTENCE_START> { return jni get max motor torque ( addr ) ; } <SENTENCE_END/>

(Copy Probability: 100.0%)

<SENTENCE_START> { return jni get max motor torque ( addr ) ; } <SENTENCE_END/>

torque

<SENTENCE_START> { return jni get max motor torque ( addr ) ; } <SENTENCE_END/>

(Copy Probability: 88.0%)

<SENTENCE_START> { return jni get max motor torque ( addr ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return jni get max motor torque ( addr ) ; } <SENTENCE_END/>

(Copy Probability: 7.1%)

<SENTENCE_START> { return jni get max motor torque ( addr ) ; } <SENTENCE_END/>

Original Name get,preferred,size

get

<SENTENCE_START> { dimension size = super . %SELF% ( ) ; size . width = 10 ; return size ; } <SENTENCE_END/>

(Copy Probability: 0.8%)

<SENTENCE_START> { dimension size = super . %SELF% ( ) ; size . width = 10 ; return size ; } <SENTENCE_END/>

preferred

<SENTENCE_START> { dimension size = super . %SELF% ( ) ; size . width = 10 ; return size ; } <SENTENCE_END/>

(Copy Probability: 5.0%)

<SENTENCE_START> { dimension size = super . %SELF% ( ) ; size . width = 10 ; return size ; } <SENTENCE_END/>

size

<SENTENCE_START> { dimension size = super . %SELF% ( ) ; size . width = 10 ; return size ; } <SENTENCE_END/>

(Copy Probability: 1.3%)

<SENTENCE_START> { dimension size = super . %SELF% ( ) ; size . width = 10 ; return size ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { dimension size = super . %SELF% ( ) ; size . width = 10 ; return size ; } <SENTENCE_END/>

(Copy Probability: 1.9%)

<SENTENCE_START> { dimension size = super . %SELF% ( ) ; size . width = 10 ; return size ; } <SENTENCE_END/>

Original Name initialize,components

initialize

<SENTENCE_START> { super . %SELF% ( ) ; j panel content panel = get content panel ( ) ; { gradient editor = new gradient editor ( ) { public void handle selected ( color color ) { gradient panel . this . set color ( color ) ; } } ; content panel . add ( gradient editor , new grid bag constraints ( 0 , 1 , 3 , 1 , 1.0 , 0.0 , grid bag constraints . center , grid bag constraints . horizontal , new insets ( 0 , 0 , 6 , 0 ) , 0 , 10 ) ) ; } { hue slider = new color slider ( new color [ ] { color . red , color . yellow , color . green , color . cyan , color . blue , color . magenta , color . red } ) { protected void color picked ( ) { saturation slider . set colors ( new color [ ] { new color ( color . hs bto rgb ( get percentage ( ) , 1 , 1 ) ) , color . white } ) ; update color ( ) ; } } ; content panel . add ( hue slider , new grid bag constraints ( 1 , 2 , 2 , 1 , 1.0 , 0.0 , grid bag constraints . center , grid bag constraints . horizontal , new insets ( 0 , 0 , 6 , 0 ) , 0 , 0 ) ) ; } { saturation slider = new color slider ( new color [ ] { color . red , color . white } ) { protected void color picked ( ) { update color ( ) ; } } ; content panel . add ( saturation slider , new grid bag constraints ( 1 , 3 , 1 , 1 , 1.0 , 0.0 , grid bag constraints . center , grid bag constraints . horizontal , new insets ( 0 , 0 , 0 , 6 ) , 0 , 0 ) ) ; } { lightness slider = new color slider ( new color [ 0 ] ) { protected void color picked ( ) { update color ( ) ; } } ; content panel . add ( lightness slider , new grid bag constraints ( 2 , 3 , 1 , 1 , 1 , 0.0 , grid bag constraints . center , grid bag constraints . horizontal , new insets ( 0 , 0 , 0 , 0 ) , 0 , 0 ) ) ; } { color panel = new j panel ( ) { public dimension get preferred size ( ) { dimension size = super . get preferred size ( ) ; size . width = 52 ; return size ; } } ; content panel . add ( color panel , new grid bag constraints ( 0 , 2 , 1 , 2 , 0.0 , 0.0 , grid bag constraints . center , grid bag constraints . both , new insets ( 3 , 0 , 0 , 6 ) , 0 , 0 ) ) ; } color panel . add mouse listener ( new mouse adapter ( ) { public void mouse clicked ( mouse event e ) { color color = j color chooser . show dialog ( color panel , "Set Color" , color panel . get background ( ) ) ; if ( color != null ) set color ( color ) ; } } ) ; color panel . set border ( border factory . create matte border ( 1 , 1 , 1 , 1 , color . black ) ) ; } <SENTENCE_END/>

(Copy Probability: 4.3%)

<SENTENCE_START> { super . %SELF% ( ) ; j panel content panel = get content panel ( ) ; { gradient editor = new gradient editor ( ) { public void handle selected ( color color ) { gradient panel . this . set color ( color ) ; } } ; content panel . add ( gradient editor , new grid bag constraints ( 0 , 1 , 3 , 1 , 1.0 , 0.0 , grid bag constraints . center , grid bag constraints . horizontal , new insets ( 0 , 0 , 6 , 0 ) , 0 , 10 ) ) ; } { hue slider = new color slider ( new color [ ] { color . red , color . yellow , color . green , color . cyan , color . blue , color . magenta , color . red } ) { protected void color picked ( ) { saturation slider . set colors ( new color [ ] { new color ( color . hs bto rgb ( get percentage ( ) , 1 , 1 ) ) , color . white } ) ; update color ( ) ; } } ; content panel . add ( hue slider , new grid bag constraints ( 1 , 2 , 2 , 1 , 1.0 , 0.0 , grid bag constraints . center , grid bag constraints . horizontal , new insets ( 0 , 0 , 6 , 0 ) , 0 , 0 ) ) ; } { saturation slider = new color slider ( new color [ ] { color . red , color . white } ) { protected void color picked ( ) { update color ( ) ; } } ; content panel . add ( saturation slider , new grid bag constraints ( 1 , 3 , 1 , 1 , 1.0 , 0.0 , grid bag constraints . center , grid bag constraints . horizontal , new insets ( 0 , 0 , 0 , 6 ) , 0 , 0 ) ) ; } { lightness slider = new color slider ( new color [ 0 ] ) { protected void color picked ( ) { update color ( ) ; } } ; content panel . add ( lightness slider , new grid bag constraints ( 2 , 3 , 1 , 1 , 1 , 0.0 , grid bag constraints . center , grid bag constraints . horizontal , new insets ( 0 , 0 , 0 , 0 ) , 0 , 0 ) ) ; } { color panel = new j panel ( ) { public dimension get preferred size ( ) { dimension size = super . get preferred size ( ) ; size . width = 52 ; return size ; } } ; content panel . add ( color panel , new grid bag constraints ( 0 , 2 , 1 , 2 , 0.0 , 0.0 , grid bag constraints . center , grid bag constraints . both , new insets ( 3 , 0 , 0 , 6 ) , 0 , 0 ) ) ; } color panel . add mouse listener ( new mouse adapter ( ) { public void mouse clicked ( mouse event e ) { color color = j color chooser . show dialog ( color panel , "Set Color" , color panel . get background ( ) ) ; if ( color != null ) set color ( color ) ; } } ) ; color panel . set border ( border factory . create matte border ( 1 , 1 , 1 , 1 , color . black ) ) ; } <SENTENCE_END/>

components

<SENTENCE_START> { super . %SELF% ( ) ; j panel content panel = get content panel ( ) ; { gradient editor = new gradient editor ( ) { public void handle selected ( color color ) { gradient panel . this . set color ( color ) ; } } ; content panel . add ( gradient editor , new grid bag constraints ( 0 , 1 , 3 , 1 , 1.0 , 0.0 , grid bag constraints . center , grid bag constraints . horizontal , new insets ( 0 , 0 , 6 , 0 ) , 0 , 10 ) ) ; } { hue slider = new color slider ( new color [ ] { color . red , color . yellow , color . green , color . cyan , color . blue , color . magenta , color . red } ) { protected void color picked ( ) { saturation slider . set colors ( new color [ ] { new color ( color . hs bto rgb ( get percentage ( ) , 1 , 1 ) ) , color . white } ) ; update color ( ) ; } } ; content panel . add ( hue slider , new grid bag constraints ( 1 , 2 , 2 , 1 , 1.0 , 0.0 , grid bag constraints . center , grid bag constraints . horizontal , new insets ( 0 , 0 , 6 , 0 ) , 0 , 0 ) ) ; } { saturation slider = new color slider ( new color [ ] { color . red , color . white } ) { protected void color picked ( ) { update color ( ) ; } } ; content panel . add ( saturation slider , new grid bag constraints ( 1 , 3 , 1 , 1 , 1.0 , 0.0 , grid bag constraints . center , grid bag constraints . horizontal , new insets ( 0 , 0 , 0 , 6 ) , 0 , 0 ) ) ; } { lightness slider = new color slider ( new color [ 0 ] ) { protected void color picked ( ) { update color ( ) ; } } ; content panel . add ( lightness slider , new grid bag constraints ( 2 , 3 , 1 , 1 , 1 , 0.0 , grid bag constraints . center , grid bag constraints . horizontal , new insets ( 0 , 0 , 0 , 0 ) , 0 , 0 ) ) ; } { color panel = new j panel ( ) { public dimension get preferred size ( ) { dimension size = super . get preferred size ( ) ; size . width = 52 ; return size ; } } ; content panel . add ( color panel , new grid bag constraints ( 0 , 2 , 1 , 2 , 0.0 , 0.0 , grid bag constraints . center , grid bag constraints . both , new insets ( 3 , 0 , 0 , 6 ) , 0 , 0 ) ) ; } color panel . add mouse listener ( new mouse adapter ( ) { public void mouse clicked ( mouse event e ) { color color = j color chooser . show dialog ( color panel , "Set Color" , color panel . get background ( ) ) ; if ( color != null ) set color ( color ) ; } } ) ; color panel . set border ( border factory . create matte border ( 1 , 1 , 1 , 1 , color . black ) ) ; } <SENTENCE_END/>

(Copy Probability: 6.5%)

<SENTENCE_START> { super . %SELF% ( ) ; j panel content panel = get content panel ( ) ; { gradient editor = new gradient editor ( ) { public void handle selected ( color color ) { gradient panel . this . set color ( color ) ; } } ; content panel . add ( gradient editor , new grid bag constraints ( 0 , 1 , 3 , 1 , 1.0 , 0.0 , grid bag constraints . center , grid bag constraints . horizontal , new insets ( 0 , 0 , 6 , 0 ) , 0 , 10 ) ) ; } { hue slider = new color slider ( new color [ ] { color . red , color . yellow , color . green , color . cyan , color . blue , color . magenta , color . red } ) { protected void color picked ( ) { saturation slider . set colors ( new color [ ] { new color ( color . hs bto rgb ( get percentage ( ) , 1 , 1 ) ) , color . white } ) ; update color ( ) ; } } ; content panel . add ( hue slider , new grid bag constraints ( 1 , 2 , 2 , 1 , 1.0 , 0.0 , grid bag constraints . center , grid bag constraints . horizontal , new insets ( 0 , 0 , 6 , 0 ) , 0 , 0 ) ) ; } { saturation slider = new color slider ( new color [ ] { color . red , color . white } ) { protected void color picked ( ) { update color ( ) ; } } ; content panel . add ( saturation slider , new grid bag constraints ( 1 , 3 , 1 , 1 , 1.0 , 0.0 , grid bag constraints . center , grid bag constraints . horizontal , new insets ( 0 , 0 , 0 , 6 ) , 0 , 0 ) ) ; } { lightness slider = new color slider ( new color [ 0 ] ) { protected void color picked ( ) { update color ( ) ; } } ; content panel . add ( lightness slider , new grid bag constraints ( 2 , 3 , 1 , 1 , 1 , 0.0 , grid bag constraints . center , grid bag constraints . horizontal , new insets ( 0 , 0 , 0 , 0 ) , 0 , 0 ) ) ; } { color panel = new j panel ( ) { public dimension get preferred size ( ) { dimension size = super . get preferred size ( ) ; size . width = 52 ; return size ; } } ; content panel . add ( color panel , new grid bag constraints ( 0 , 2 , 1 , 2 , 0.0 , 0.0 , grid bag constraints . center , grid bag constraints . both , new insets ( 3 , 0 , 0 , 6 ) , 0 , 0 ) ) ; } color panel . add mouse listener ( new mouse adapter ( ) { public void mouse clicked ( mouse event e ) { color color = j color chooser . show dialog ( color panel , "Set Color" , color panel . get background ( ) ) ; if ( color != null ) set color ( color ) ; } } ) ; color panel . set border ( border factory . create matte border ( 1 , 1 , 1 , 1 , color . black ) ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { super . %SELF% ( ) ; j panel content panel = get content panel ( ) ; { gradient editor = new gradient editor ( ) { public void handle selected ( color color ) { gradient panel . this . set color ( color ) ; } } ; content panel . add ( gradient editor , new grid bag constraints ( 0 , 1 , 3 , 1 , 1.0 , 0.0 , grid bag constraints . center , grid bag constraints . horizontal , new insets ( 0 , 0 , 6 , 0 ) , 0 , 10 ) ) ; } { hue slider = new color slider ( new color [ ] { color . red , color . yellow , color . green , color . cyan , color . blue , color . magenta , color . red } ) { protected void color picked ( ) { saturation slider . set colors ( new color [ ] { new color ( color . hs bto rgb ( get percentage ( ) , 1 , 1 ) ) , color . white } ) ; update color ( ) ; } } ; content panel . add ( hue slider , new grid bag constraints ( 1 , 2 , 2 , 1 , 1.0 , 0.0 , grid bag constraints . center , grid bag constraints . horizontal , new insets ( 0 , 0 , 6 , 0 ) , 0 , 0 ) ) ; } { saturation slider = new color slider ( new color [ ] { color . red , color . white } ) { protected void color picked ( ) { update color ( ) ; } } ; content panel . add ( saturation slider , new grid bag constraints ( 1 , 3 , 1 , 1 , 1.0 , 0.0 , grid bag constraints . center , grid bag constraints . horizontal , new insets ( 0 , 0 , 0 , 6 ) , 0 , 0 ) ) ; } { lightness slider = new color slider ( new color [ 0 ] ) { protected void color picked ( ) { update color ( ) ; } } ; content panel . add ( lightness slider , new grid bag constraints ( 2 , 3 , 1 , 1 , 1 , 0.0 , grid bag constraints . center , grid bag constraints . horizontal , new insets ( 0 , 0 , 0 , 0 ) , 0 , 0 ) ) ; } { color panel = new j panel ( ) { public dimension get preferred size ( ) { dimension size = super . get preferred size ( ) ; size . width = 52 ; return size ; } } ; content panel . add ( color panel , new grid bag constraints ( 0 , 2 , 1 , 2 , 0.0 , 0.0 , grid bag constraints . center , grid bag constraints . both , new insets ( 3 , 0 , 0 , 6 ) , 0 , 0 ) ) ; } color panel . add mouse listener ( new mouse adapter ( ) { public void mouse clicked ( mouse event e ) { color color = j color chooser . show dialog ( color panel , "Set Color" , color panel . get background ( ) ) ; if ( color != null ) set color ( color ) ; } } ) ; color panel . set border ( border factory . create matte border ( 1 , 1 , 1 , 1 , color . black ) ) ; } <SENTENCE_END/>

(Copy Probability: 4.9%)

<SENTENCE_START> { super . %SELF% ( ) ; j panel content panel = get content panel ( ) ; { gradient editor = new gradient editor ( ) { public void handle selected ( color color ) { gradient panel . this . set color ( color ) ; } } ; content panel . add ( gradient editor , new grid bag constraints ( 0 , 1 , 3 , 1 , 1.0 , 0.0 , grid bag constraints . center , grid bag constraints . horizontal , new insets ( 0 , 0 , 6 , 0 ) , 0 , 10 ) ) ; } { hue slider = new color slider ( new color [ ] { color . red , color . yellow , color . green , color . cyan , color . blue , color . magenta , color . red } ) { protected void color picked ( ) { saturation slider . set colors ( new color [ ] { new color ( color . hs bto rgb ( get percentage ( ) , 1 , 1 ) ) , color . white } ) ; update color ( ) ; } } ; content panel . add ( hue slider , new grid bag constraints ( 1 , 2 , 2 , 1 , 1.0 , 0.0 , grid bag constraints . center , grid bag constraints . horizontal , new insets ( 0 , 0 , 6 , 0 ) , 0 , 0 ) ) ; } { saturation slider = new color slider ( new color [ ] { color . red , color . white } ) { protected void color picked ( ) { update color ( ) ; } } ; content panel . add ( saturation slider , new grid bag constraints ( 1 , 3 , 1 , 1 , 1.0 , 0.0 , grid bag constraints . center , grid bag constraints . horizontal , new insets ( 0 , 0 , 0 , 6 ) , 0 , 0 ) ) ; } { lightness slider = new color slider ( new color [ 0 ] ) { protected void color picked ( ) { update color ( ) ; } } ; content panel . add ( lightness slider , new grid bag constraints ( 2 , 3 , 1 , 1 , 1 , 0.0 , grid bag constraints . center , grid bag constraints . horizontal , new insets ( 0 , 0 , 0 , 0 ) , 0 , 0 ) ) ; } { color panel = new j panel ( ) { public dimension get preferred size ( ) { dimension size = super . get preferred size ( ) ; size . width = 52 ; return size ; } } ; content panel . add ( color panel , new grid bag constraints ( 0 , 2 , 1 , 2 , 0.0 , 0.0 , grid bag constraints . center , grid bag constraints . both , new insets ( 3 , 0 , 0 , 6 ) , 0 , 0 ) ) ; } color panel . add mouse listener ( new mouse adapter ( ) { public void mouse clicked ( mouse event e ) { color color = j color chooser . show dialog ( color panel , "Set Color" , color panel . get background ( ) ) ; if ( color != null ) set color ( color ) ; } } ) ; color panel . set border ( border factory . create matte border ( 1 , 1 , 1 , 1 , color . black ) ) ; } <SENTENCE_END/>

Original Name handle,selected

handle

<SENTENCE_START> { gradient panel . this . set color ( color ) ; } <SENTENCE_END/>

(Copy Probability: 0.9%)

<SENTENCE_START> { gradient panel . this . set color ( color ) ; } <SENTENCE_END/>

selected

<SENTENCE_START> { gradient panel . this . set color ( color ) ; } <SENTENCE_END/>

(Copy Probability: 16.8%)

<SENTENCE_START> { gradient panel . this . set color ( color ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { gradient panel . this . set color ( color ) ; } <SENTENCE_END/>

(Copy Probability: 0.7%)

<SENTENCE_START> { gradient panel . this . set color ( color ) ; } <SENTENCE_END/>

Original Name color,picked

color

<SENTENCE_START> { saturation slider . set colors ( new color [ ] { new color ( color . hs bto rgb ( get percentage ( ) , 1 , 1 ) ) , color . white } ) ; update color ( ) ; } <SENTENCE_END/>

(Copy Probability: 1.9%)

<SENTENCE_START> { saturation slider . set colors ( new color [ ] { new color ( color . hs bto rgb ( get percentage ( ) , 1 , 1 ) ) , color . white } ) ; update color ( ) ; } <SENTENCE_END/>

picked

<SENTENCE_START> { saturation slider . set colors ( new color [ ] { new color ( color . hs bto rgb ( get percentage ( ) , 1 , 1 ) ) , color . white } ) ; update color ( ) ; } <SENTENCE_END/>

(Copy Probability: 6.1%)

<SENTENCE_START> { saturation slider . set colors ( new color [ ] { new color ( color . hs bto rgb ( get percentage ( ) , 1 , 1 ) ) , color . white } ) ; update color ( ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { saturation slider . set colors ( new color [ ] { new color ( color . hs bto rgb ( get percentage ( ) , 1 , 1 ) ) , color . white } ) ; update color ( ) ; } <SENTENCE_END/>

(Copy Probability: 4.1%)

<SENTENCE_START> { saturation slider . set colors ( new color [ ] { new color ( color . hs bto rgb ( get percentage ( ) , 1 , 1 ) ) , color . white } ) ; update color ( ) ; } <SENTENCE_END/>

Original Name color,picked

color

<SENTENCE_START> { update color ( ) ; } <SENTENCE_END/>

(Copy Probability: 0.5%)

<SENTENCE_START> { update color ( ) ; } <SENTENCE_END/>

picked

<SENTENCE_START> { update color ( ) ; } <SENTENCE_END/>

(Copy Probability: 1.8%)

<SENTENCE_START> { update color ( ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { update color ( ) ; } <SENTENCE_END/>

(Copy Probability: 0.3%)

<SENTENCE_START> { update color ( ) ; } <SENTENCE_END/>

Original Name color,picked

color

<SENTENCE_START> { update color ( ) ; } <SENTENCE_END/>

(Copy Probability: 0.5%)

<SENTENCE_START> { update color ( ) ; } <SENTENCE_END/>

picked

<SENTENCE_START> { update color ( ) ; } <SENTENCE_END/>

(Copy Probability: 1.8%)

<SENTENCE_START> { update color ( ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { update color ( ) ; } <SENTENCE_END/>

(Copy Probability: 0.3%)

<SENTENCE_START> { update color ( ) ; } <SENTENCE_END/>

Original Name get,preferred,size

get

<SENTENCE_START> { dimension size = super . %SELF% ( ) ; size . width = 52 ; return size ; } <SENTENCE_END/>

(Copy Probability: 0.8%)

<SENTENCE_START> { dimension size = super . %SELF% ( ) ; size . width = 52 ; return size ; } <SENTENCE_END/>

preferred

<SENTENCE_START> { dimension size = super . %SELF% ( ) ; size . width = 52 ; return size ; } <SENTENCE_END/>

(Copy Probability: 5.5%)

<SENTENCE_START> { dimension size = super . %SELF% ( ) ; size . width = 52 ; return size ; } <SENTENCE_END/>

size

<SENTENCE_START> { dimension size = super . %SELF% ( ) ; size . width = 52 ; return size ; } <SENTENCE_END/>

(Copy Probability: 1.3%)

<SENTENCE_START> { dimension size = super . %SELF% ( ) ; size . width = 52 ; return size ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { dimension size = super . %SELF% ( ) ; size . width = 52 ; return size ; } <SENTENCE_END/>

(Copy Probability: 1.9%)

<SENTENCE_START> { dimension size = super . %SELF% ( ) ; size . width = 52 ; return size ; } <SENTENCE_END/>

Original Name mouse,clicked

mouse

<SENTENCE_START> { color color = j color chooser . show dialog ( color panel , "Set Color" , color panel . get background ( ) ) ; if ( color != null ) set color ( color ) ; } <SENTENCE_END/>

(Copy Probability: 1.6%)

<SENTENCE_START> { color color = j color chooser . show dialog ( color panel , "Set Color" , color panel . get background ( ) ) ; if ( color != null ) set color ( color ) ; } <SENTENCE_END/>

clicked

<SENTENCE_START> { color color = j color chooser . show dialog ( color panel , "Set Color" , color panel . get background ( ) ) ; if ( color != null ) set color ( color ) ; } <SENTENCE_END/>

(Copy Probability: 12.8%)

<SENTENCE_START> { color color = j color chooser . show dialog ( color panel , "Set Color" , color panel . get background ( ) ) ; if ( color != null ) set color ( color ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { color color = j color chooser . show dialog ( color panel , "Set Color" , color panel . get background ( ) ) ; if ( color != null ) set color ( color ) ; } <SENTENCE_END/>

(Copy Probability: 6.7%)

<SENTENCE_START> { color color = j color chooser . show dialog ( color panel , "Set Color" , color panel . get background ( ) ) ; if ( color != null ) set color ( color ) ; } <SENTENCE_END/>

Original Name set,color

set

<SENTENCE_START> { float [ ] hsb = color . rg bto hsb ( color . get red ( ) , color . get green ( ) , color . get blue ( ) , null ) ; hue slider . set percentage ( hsb [ 0 ] ) ; saturation slider . set percentage ( 1 - hsb [ 1 ] ) ; lightness slider . set percentage ( 1 - hsb [ 2 ] ) ; color panel . set background ( color ) ; } <SENTENCE_END/>

(Copy Probability: 2.8%)

<SENTENCE_START> { float [ ] hsb = color . rg bto hsb ( color . get red ( ) , color . get green ( ) , color . get blue ( ) , null ) ; hue slider . set percentage ( hsb [ 0 ] ) ; saturation slider . set percentage ( 1 - hsb [ 1 ] ) ; lightness slider . set percentage ( 1 - hsb [ 2 ] ) ; color panel . set background ( color ) ; } <SENTENCE_END/>

color

<SENTENCE_START> { float [ ] hsb = color . rg bto hsb ( color . get red ( ) , color . get green ( ) , color . get blue ( ) , null ) ; hue slider . set percentage ( hsb [ 0 ] ) ; saturation slider . set percentage ( 1 - hsb [ 1 ] ) ; lightness slider . set percentage ( 1 - hsb [ 2 ] ) ; color panel . set background ( color ) ; } <SENTENCE_END/>

(Copy Probability: 15.8%)

<SENTENCE_START> { float [ ] hsb = color . rg bto hsb ( color . get red ( ) , color . get green ( ) , color . get blue ( ) , null ) ; hue slider . set percentage ( hsb [ 0 ] ) ; saturation slider . set percentage ( 1 - hsb [ 1 ] ) ; lightness slider . set percentage ( 1 - hsb [ 2 ] ) ; color panel . set background ( color ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { float [ ] hsb = color . rg bto hsb ( color . get red ( ) , color . get green ( ) , color . get blue ( ) , null ) ; hue slider . set percentage ( hsb [ 0 ] ) ; saturation slider . set percentage ( 1 - hsb [ 1 ] ) ; lightness slider . set percentage ( 1 - hsb [ 2 ] ) ; color panel . set background ( color ) ; } <SENTENCE_END/>

(Copy Probability: 7.6%)

<SENTENCE_START> { float [ ] hsb = color . rg bto hsb ( color . get red ( ) , color . get green ( ) , color . get blue ( ) , null ) ; hue slider . set percentage ( hsb [ 0 ] ) ; saturation slider . set percentage ( 1 - hsb [ 1 ] ) ; lightness slider . set percentage ( 1 - hsb [ 2 ] ) ; color panel . set background ( color ) ; } <SENTENCE_END/>

Original Name update,color

update

<SENTENCE_START> { color color = new color ( color . hs bto rgb ( hue slider . get percentage ( ) , 1 - saturation slider . get percentage ( ) , 1 ) ) ; lightness slider . set colors ( new color [ ] { color , color . black } ) ; color = new color ( color . hs bto rgb ( hue slider . get percentage ( ) , 1 - saturation slider . get percentage ( ) , 1 - lightness slider . get percentage ( ) ) ) ; color panel . set background ( color ) ; gradient editor . set color ( color ) ; float [ ] colors = new float [ gradient editor . colors . size ( ) * 3 ] ; int i = 0 ; for ( color c : gradient editor . colors ) { colors [ i ++ ] = c . get red ( ) / 255f ; colors [ i ++ ] = c . get green ( ) / 255f ; colors [ i ++ ] = c . get blue ( ) / 255f ; } float [ ] percentages = new float [ gradient editor . percentages . size ( ) ] ; i = 0 ; for ( float percent : gradient editor . percentages ) percentages [ i ++ ] = percent ; value . set colors ( colors ) ; value . set timeline ( percentages ) ; } <SENTENCE_END/>

(Copy Probability: 3.2%)

<SENTENCE_START> { color color = new color ( color . hs bto rgb ( hue slider . get percentage ( ) , 1 - saturation slider . get percentage ( ) , 1 ) ) ; lightness slider . set colors ( new color [ ] { color , color . black } ) ; color = new color ( color . hs bto rgb ( hue slider . get percentage ( ) , 1 - saturation slider . get percentage ( ) , 1 - lightness slider . get percentage ( ) ) ) ; color panel . set background ( color ) ; gradient editor . set color ( color ) ; float [ ] colors = new float [ gradient editor . colors . size ( ) * 3 ] ; int i = 0 ; for ( color c : gradient editor . colors ) { colors [ i ++ ] = c . get red ( ) / 255f ; colors [ i ++ ] = c . get green ( ) / 255f ; colors [ i ++ ] = c . get blue ( ) / 255f ; } float [ ] percentages = new float [ gradient editor . percentages . size ( ) ] ; i = 0 ; for ( float percent : gradient editor . percentages ) percentages [ i ++ ] = percent ; value . set colors ( colors ) ; value . set timeline ( percentages ) ; } <SENTENCE_END/>

color

<SENTENCE_START> { color color = new color ( color . hs bto rgb ( hue slider . get percentage ( ) , 1 - saturation slider . get percentage ( ) , 1 ) ) ; lightness slider . set colors ( new color [ ] { color , color . black } ) ; color = new color ( color . hs bto rgb ( hue slider . get percentage ( ) , 1 - saturation slider . get percentage ( ) , 1 - lightness slider . get percentage ( ) ) ) ; color panel . set background ( color ) ; gradient editor . set color ( color ) ; float [ ] colors = new float [ gradient editor . colors . size ( ) * 3 ] ; int i = 0 ; for ( color c : gradient editor . colors ) { colors [ i ++ ] = c . get red ( ) / 255f ; colors [ i ++ ] = c . get green ( ) / 255f ; colors [ i ++ ] = c . get blue ( ) / 255f ; } float [ ] percentages = new float [ gradient editor . percentages . size ( ) ] ; i = 0 ; for ( float percent : gradient editor . percentages ) percentages [ i ++ ] = percent ; value . set colors ( colors ) ; value . set timeline ( percentages ) ; } <SENTENCE_END/>

(Copy Probability: 6.4%)

<SENTENCE_START> { color color = new color ( color . hs bto rgb ( hue slider . get percentage ( ) , 1 - saturation slider . get percentage ( ) , 1 ) ) ; lightness slider . set colors ( new color [ ] { color , color . black } ) ; color = new color ( color . hs bto rgb ( hue slider . get percentage ( ) , 1 - saturation slider . get percentage ( ) , 1 - lightness slider . get percentage ( ) ) ) ; color panel . set background ( color ) ; gradient editor . set color ( color ) ; float [ ] colors = new float [ gradient editor . colors . size ( ) * 3 ] ; int i = 0 ; for ( color c : gradient editor . colors ) { colors [ i ++ ] = c . get red ( ) / 255f ; colors [ i ++ ] = c . get green ( ) / 255f ; colors [ i ++ ] = c . get blue ( ) / 255f ; } float [ ] percentages = new float [ gradient editor . percentages . size ( ) ] ; i = 0 ; for ( float percent : gradient editor . percentages ) percentages [ i ++ ] = percent ; value . set colors ( colors ) ; value . set timeline ( percentages ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { color color = new color ( color . hs bto rgb ( hue slider . get percentage ( ) , 1 - saturation slider . get percentage ( ) , 1 ) ) ; lightness slider . set colors ( new color [ ] { color , color . black } ) ; color = new color ( color . hs bto rgb ( hue slider . get percentage ( ) , 1 - saturation slider . get percentage ( ) , 1 - lightness slider . get percentage ( ) ) ) ; color panel . set background ( color ) ; gradient editor . set color ( color ) ; float [ ] colors = new float [ gradient editor . colors . size ( ) * 3 ] ; int i = 0 ; for ( color c : gradient editor . colors ) { colors [ i ++ ] = c . get red ( ) / 255f ; colors [ i ++ ] = c . get green ( ) / 255f ; colors [ i ++ ] = c . get blue ( ) / 255f ; } float [ ] percentages = new float [ gradient editor . percentages . size ( ) ] ; i = 0 ; for ( float percent : gradient editor . percentages ) percentages [ i ++ ] = percent ; value . set colors ( colors ) ; value . set timeline ( percentages ) ; } <SENTENCE_END/>

(Copy Probability: 3.7%)

<SENTENCE_START> { color color = new color ( color . hs bto rgb ( hue slider . get percentage ( ) , 1 - saturation slider . get percentage ( ) , 1 ) ) ; lightness slider . set colors ( new color [ ] { color , color . black } ) ; color = new color ( color . hs bto rgb ( hue slider . get percentage ( ) , 1 - saturation slider . get percentage ( ) , 1 - lightness slider . get percentage ( ) ) ) ; color panel . set background ( color ) ; gradient editor . set color ( color ) ; float [ ] colors = new float [ gradient editor . colors . size ( ) * 3 ] ; int i = 0 ; for ( color c : gradient editor . colors ) { colors [ i ++ ] = c . get red ( ) / 255f ; colors [ i ++ ] = c . get green ( ) / 255f ; colors [ i ++ ] = c . get blue ( ) / 255f ; } float [ ] percentages = new float [ gradient editor . percentages . size ( ) ] ; i = 0 ; for ( float percent : gradient editor . percentages ) percentages [ i ++ ] = percent ; value . set colors ( colors ) ; value . set timeline ( percentages ) ; } <SENTENCE_END/>

Original Name mouse,pressed

mouse

<SENTENCE_START> { drag index = - 1 ; int mouse x = event . get x ( ) ; int mouse y = event . get y ( ) ; int y = gradient y + gradient height ; for ( int i = 0 , n = colors . size ( ) ; i < n ; i ++ ) { int x = gradient x + ( int ) ( percentages . get ( i ) * gradient width ) - handle width / 2 ; if ( mouse x >= x && mouse x <= x + handle width && mouse y >= gradient y && mouse y <= y + handle height ) { drag index = selected index = i ; handle selected ( colors . get ( selected index ) ) ; repaint ( ) ; break ; } } } <SENTENCE_END/>

(Copy Probability: 3.6%)

<SENTENCE_START> { drag index = - 1 ; int mouse x = event . get x ( ) ; int mouse y = event . get y ( ) ; int y = gradient y + gradient height ; for ( int i = 0 , n = colors . size ( ) ; i < n ; i ++ ) { int x = gradient x + ( int ) ( percentages . get ( i ) * gradient width ) - handle width / 2 ; if ( mouse x >= x && mouse x <= x + handle width && mouse y >= gradient y && mouse y <= y + handle height ) { drag index = selected index = i ; handle selected ( colors . get ( selected index ) ) ; repaint ( ) ; break ; } } } <SENTENCE_END/>

pressed

<SENTENCE_START> { drag index = - 1 ; int mouse x = event . get x ( ) ; int mouse y = event . get y ( ) ; int y = gradient y + gradient height ; for ( int i = 0 , n = colors . size ( ) ; i < n ; i ++ ) { int x = gradient x + ( int ) ( percentages . get ( i ) * gradient width ) - handle width / 2 ; if ( mouse x >= x && mouse x <= x + handle width && mouse y >= gradient y && mouse y <= y + handle height ) { drag index = selected index = i ; handle selected ( colors . get ( selected index ) ) ; repaint ( ) ; break ; } } } <SENTENCE_END/>

(Copy Probability: 7.6%)

<SENTENCE_START> { drag index = - 1 ; int mouse x = event . get x ( ) ; int mouse y = event . get y ( ) ; int y = gradient y + gradient height ; for ( int i = 0 , n = colors . size ( ) ; i < n ; i ++ ) { int x = gradient x + ( int ) ( percentages . get ( i ) * gradient width ) - handle width / 2 ; if ( mouse x >= x && mouse x <= x + handle width && mouse y >= gradient y && mouse y <= y + handle height ) { drag index = selected index = i ; handle selected ( colors . get ( selected index ) ) ; repaint ( ) ; break ; } } } <SENTENCE_END/>

%END%

<SENTENCE_START> { drag index = - 1 ; int mouse x = event . get x ( ) ; int mouse y = event . get y ( ) ; int y = gradient y + gradient height ; for ( int i = 0 , n = colors . size ( ) ; i < n ; i ++ ) { int x = gradient x + ( int ) ( percentages . get ( i ) * gradient width ) - handle width / 2 ; if ( mouse x >= x && mouse x <= x + handle width && mouse y >= gradient y && mouse y <= y + handle height ) { drag index = selected index = i ; handle selected ( colors . get ( selected index ) ) ; repaint ( ) ; break ; } } } <SENTENCE_END/>

(Copy Probability: 6.2%)

<SENTENCE_START> { drag index = - 1 ; int mouse x = event . get x ( ) ; int mouse y = event . get y ( ) ; int y = gradient y + gradient height ; for ( int i = 0 , n = colors . size ( ) ; i < n ; i ++ ) { int x = gradient x + ( int ) ( percentages . get ( i ) * gradient width ) - handle width / 2 ; if ( mouse x >= x && mouse x <= x + handle width && mouse y >= gradient y && mouse y <= y + handle height ) { drag index = selected index = i ; handle selected ( colors . get ( selected index ) ) ; repaint ( ) ; break ; } } } <SENTENCE_END/>

Original Name mouse,released

mouse

<SENTENCE_START> { if ( drag index != - 1 ) { drag index = - 1 ; repaint ( ) ; } } <SENTENCE_END/>

(Copy Probability: 1.2%)

<SENTENCE_START> { if ( drag index != - 1 ) { drag index = - 1 ; repaint ( ) ; } } <SENTENCE_END/>

released

<SENTENCE_START> { if ( drag index != - 1 ) { drag index = - 1 ; repaint ( ) ; } } <SENTENCE_END/>

(Copy Probability: 3.1%)

<SENTENCE_START> { if ( drag index != - 1 ) { drag index = - 1 ; repaint ( ) ; } } <SENTENCE_END/>

%END%

<SENTENCE_START> { if ( drag index != - 1 ) { drag index = - 1 ; repaint ( ) ; } } <SENTENCE_END/>

(Copy Probability: 0.9%)

<SENTENCE_START> { if ( drag index != - 1 ) { drag index = - 1 ; repaint ( ) ; } } <SENTENCE_END/>

Original Name mouse,clicked

mouse

<SENTENCE_START> { int mouse x = event . get x ( ) ; int mouse y = event . get y ( ) ; if ( event . get click count ( ) == 2 ) { if ( percentages . size ( ) <= 1 ) return ; if ( selected index == - 1 || selected index == 0 ) return ; int y = gradient y + gradient height ; int x = gradient x + ( int ) ( percentages . get ( selected index ) * gradient width ) - handle width / 2 ; if ( mouse x >= x && mouse x <= x + handle width && mouse y >= gradient y && mouse y <= y + handle height ) { percentages . remove ( selected index ) ; colors . remove ( selected index ) ; selected index -- ; drag index = selected index ; if ( percentages . size ( ) == 2 ) percentages . set ( 1 , 1f ) ; handle selected ( colors . get ( selected index ) ) ; repaint ( ) ; } return ; } if ( mouse x < gradient x || mouse x > gradient x + gradient width ) return ; if ( mouse y < gradient y || mouse y > gradient y + gradient height ) return ; float percent = ( event . get x ( ) - gradient x ) / ( float ) gradient width ; if ( percentages . size ( ) == 1 ) percent = 1f ; for ( int i = 0 , n = percentages . size ( ) ; i <= n ; i ++ ) { if ( i == n || percent < percentages . get ( i ) ) { percentages . add ( i , percent ) ; colors . add ( i , colors . get ( i - 1 ) ) ; drag index = selected index = i ; handle selected ( colors . get ( selected index ) ) ; repaint ( ) ; break ; } } } <SENTENCE_END/>

(Copy Probability: 3.2%)

<SENTENCE_START> { int mouse x = event . get x ( ) ; int mouse y = event . get y ( ) ; if ( event . get click count ( ) == 2 ) { if ( percentages . size ( ) <= 1 ) return ; if ( selected index == - 1 || selected index == 0 ) return ; int y = gradient y + gradient height ; int x = gradient x + ( int ) ( percentages . get ( selected index ) * gradient width ) - handle width / 2 ; if ( mouse x >= x && mouse x <= x + handle width && mouse y >= gradient y && mouse y <= y + handle height ) { percentages . remove ( selected index ) ; colors . remove ( selected index ) ; selected index -- ; drag index = selected index ; if ( percentages . size ( ) == 2 ) percentages . set ( 1 , 1f ) ; handle selected ( colors . get ( selected index ) ) ; repaint ( ) ; } return ; } if ( mouse x < gradient x || mouse x > gradient x + gradient width ) return ; if ( mouse y < gradient y || mouse y > gradient y + gradient height ) return ; float percent = ( event . get x ( ) - gradient x ) / ( float ) gradient width ; if ( percentages . size ( ) == 1 ) percent = 1f ; for ( int i = 0 , n = percentages . size ( ) ; i <= n ; i ++ ) { if ( i == n || percent < percentages . get ( i ) ) { percentages . add ( i , percent ) ; colors . add ( i , colors . get ( i - 1 ) ) ; drag index = selected index = i ; handle selected ( colors . get ( selected index ) ) ; repaint ( ) ; break ; } } } <SENTENCE_END/>

clicked

<SENTENCE_START> { int mouse x = event . get x ( ) ; int mouse y = event . get y ( ) ; if ( event . get click count ( ) == 2 ) { if ( percentages . size ( ) <= 1 ) return ; if ( selected index == - 1 || selected index == 0 ) return ; int y = gradient y + gradient height ; int x = gradient x + ( int ) ( percentages . get ( selected index ) * gradient width ) - handle width / 2 ; if ( mouse x >= x && mouse x <= x + handle width && mouse y >= gradient y && mouse y <= y + handle height ) { percentages . remove ( selected index ) ; colors . remove ( selected index ) ; selected index -- ; drag index = selected index ; if ( percentages . size ( ) == 2 ) percentages . set ( 1 , 1f ) ; handle selected ( colors . get ( selected index ) ) ; repaint ( ) ; } return ; } if ( mouse x < gradient x || mouse x > gradient x + gradient width ) return ; if ( mouse y < gradient y || mouse y > gradient y + gradient height ) return ; float percent = ( event . get x ( ) - gradient x ) / ( float ) gradient width ; if ( percentages . size ( ) == 1 ) percent = 1f ; for ( int i = 0 , n = percentages . size ( ) ; i <= n ; i ++ ) { if ( i == n || percent < percentages . get ( i ) ) { percentages . add ( i , percent ) ; colors . add ( i , colors . get ( i - 1 ) ) ; drag index = selected index = i ; handle selected ( colors . get ( selected index ) ) ; repaint ( ) ; break ; } } } <SENTENCE_END/>

(Copy Probability: 4.5%)

<SENTENCE_START> { int mouse x = event . get x ( ) ; int mouse y = event . get y ( ) ; if ( event . get click count ( ) == 2 ) { if ( percentages . size ( ) <= 1 ) return ; if ( selected index == - 1 || selected index == 0 ) return ; int y = gradient y + gradient height ; int x = gradient x + ( int ) ( percentages . get ( selected index ) * gradient width ) - handle width / 2 ; if ( mouse x >= x && mouse x <= x + handle width && mouse y >= gradient y && mouse y <= y + handle height ) { percentages . remove ( selected index ) ; colors . remove ( selected index ) ; selected index -- ; drag index = selected index ; if ( percentages . size ( ) == 2 ) percentages . set ( 1 , 1f ) ; handle selected ( colors . get ( selected index ) ) ; repaint ( ) ; } return ; } if ( mouse x < gradient x || mouse x > gradient x + gradient width ) return ; if ( mouse y < gradient y || mouse y > gradient y + gradient height ) return ; float percent = ( event . get x ( ) - gradient x ) / ( float ) gradient width ; if ( percentages . size ( ) == 1 ) percent = 1f ; for ( int i = 0 , n = percentages . size ( ) ; i <= n ; i ++ ) { if ( i == n || percent < percentages . get ( i ) ) { percentages . add ( i , percent ) ; colors . add ( i , colors . get ( i - 1 ) ) ; drag index = selected index = i ; handle selected ( colors . get ( selected index ) ) ; repaint ( ) ; break ; } } } <SENTENCE_END/>

%END%

<SENTENCE_START> { int mouse x = event . get x ( ) ; int mouse y = event . get y ( ) ; if ( event . get click count ( ) == 2 ) { if ( percentages . size ( ) <= 1 ) return ; if ( selected index == - 1 || selected index == 0 ) return ; int y = gradient y + gradient height ; int x = gradient x + ( int ) ( percentages . get ( selected index ) * gradient width ) - handle width / 2 ; if ( mouse x >= x && mouse x <= x + handle width && mouse y >= gradient y && mouse y <= y + handle height ) { percentages . remove ( selected index ) ; colors . remove ( selected index ) ; selected index -- ; drag index = selected index ; if ( percentages . size ( ) == 2 ) percentages . set ( 1 , 1f ) ; handle selected ( colors . get ( selected index ) ) ; repaint ( ) ; } return ; } if ( mouse x < gradient x || mouse x > gradient x + gradient width ) return ; if ( mouse y < gradient y || mouse y > gradient y + gradient height ) return ; float percent = ( event . get x ( ) - gradient x ) / ( float ) gradient width ; if ( percentages . size ( ) == 1 ) percent = 1f ; for ( int i = 0 , n = percentages . size ( ) ; i <= n ; i ++ ) { if ( i == n || percent < percentages . get ( i ) ) { percentages . add ( i , percent ) ; colors . add ( i , colors . get ( i - 1 ) ) ; drag index = selected index = i ; handle selected ( colors . get ( selected index ) ) ; repaint ( ) ; break ; } } } <SENTENCE_END/>

(Copy Probability: 3.9%)

<SENTENCE_START> { int mouse x = event . get x ( ) ; int mouse y = event . get y ( ) ; if ( event . get click count ( ) == 2 ) { if ( percentages . size ( ) <= 1 ) return ; if ( selected index == - 1 || selected index == 0 ) return ; int y = gradient y + gradient height ; int x = gradient x + ( int ) ( percentages . get ( selected index ) * gradient width ) - handle width / 2 ; if ( mouse x >= x && mouse x <= x + handle width && mouse y >= gradient y && mouse y <= y + handle height ) { percentages . remove ( selected index ) ; colors . remove ( selected index ) ; selected index -- ; drag index = selected index ; if ( percentages . size ( ) == 2 ) percentages . set ( 1 , 1f ) ; handle selected ( colors . get ( selected index ) ) ; repaint ( ) ; } return ; } if ( mouse x < gradient x || mouse x > gradient x + gradient width ) return ; if ( mouse y < gradient y || mouse y > gradient y + gradient height ) return ; float percent = ( event . get x ( ) - gradient x ) / ( float ) gradient width ; if ( percentages . size ( ) == 1 ) percent = 1f ; for ( int i = 0 , n = percentages . size ( ) ; i <= n ; i ++ ) { if ( i == n || percent < percentages . get ( i ) ) { percentages . add ( i , percent ) ; colors . add ( i , colors . get ( i - 1 ) ) ; drag index = selected index = i ; handle selected ( colors . get ( selected index ) ) ; repaint ( ) ; break ; } } } <SENTENCE_END/>

Original Name mouse,dragged

mouse

<SENTENCE_START> { if ( drag index == - 1 || drag index == 0 || drag index == percentages . size ( ) - 1 ) return ; float percent = ( event . get x ( ) - gradient x ) / ( float ) gradient width ; percent = math . max ( percent , percentages . get ( drag index - 1 ) + 0.01f ) ; percent = math . min ( percent , percentages . get ( drag index + 1 ) - 0.01f ) ; percentages . set ( drag index , percent ) ; repaint ( ) ; } <SENTENCE_END/>

(Copy Probability: 2.6%)

<SENTENCE_START> { if ( drag index == - 1 || drag index == 0 || drag index == percentages . size ( ) - 1 ) return ; float percent = ( event . get x ( ) - gradient x ) / ( float ) gradient width ; percent = math . max ( percent , percentages . get ( drag index - 1 ) + 0.01f ) ; percent = math . min ( percent , percentages . get ( drag index + 1 ) - 0.01f ) ; percentages . set ( drag index , percent ) ; repaint ( ) ; } <SENTENCE_END/>

dragged

<SENTENCE_START> { if ( drag index == - 1 || drag index == 0 || drag index == percentages . size ( ) - 1 ) return ; float percent = ( event . get x ( ) - gradient x ) / ( float ) gradient width ; percent = math . max ( percent , percentages . get ( drag index - 1 ) + 0.01f ) ; percent = math . min ( percent , percentages . get ( drag index + 1 ) - 0.01f ) ; percentages . set ( drag index , percent ) ; repaint ( ) ; } <SENTENCE_END/>

(Copy Probability: 4.9%)

<SENTENCE_START> { if ( drag index == - 1 || drag index == 0 || drag index == percentages . size ( ) - 1 ) return ; float percent = ( event . get x ( ) - gradient x ) / ( float ) gradient width ; percent = math . max ( percent , percentages . get ( drag index - 1 ) + 0.01f ) ; percent = math . min ( percent , percentages . get ( drag index + 1 ) - 0.01f ) ; percentages . set ( drag index , percent ) ; repaint ( ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { if ( drag index == - 1 || drag index == 0 || drag index == percentages . size ( ) - 1 ) return ; float percent = ( event . get x ( ) - gradient x ) / ( float ) gradient width ; percent = math . max ( percent , percentages . get ( drag index - 1 ) + 0.01f ) ; percent = math . min ( percent , percentages . get ( drag index + 1 ) - 0.01f ) ; percentages . set ( drag index , percent ) ; repaint ( ) ; } <SENTENCE_END/>

(Copy Probability: 4.2%)

<SENTENCE_START> { if ( drag index == - 1 || drag index == 0 || drag index == percentages . size ( ) - 1 ) return ; float percent = ( event . get x ( ) - gradient x ) / ( float ) gradient width ; percent = math . max ( percent , percentages . get ( drag index - 1 ) + 0.01f ) ; percent = math . min ( percent , percentages . get ( drag index + 1 ) - 0.01f ) ; percentages . set ( drag index , percent ) ; repaint ( ) ; } <SENTENCE_END/>

Original Name set,color

set

<SENTENCE_START> { if ( selected index == - 1 ) return ; colors . set ( selected index , color ) ; repaint ( ) ; } <SENTENCE_END/>

(Copy Probability: 1.3%)

<SENTENCE_START> { if ( selected index == - 1 ) return ; colors . set ( selected index , color ) ; repaint ( ) ; } <SENTENCE_END/>

color

<SENTENCE_START> { if ( selected index == - 1 ) return ; colors . set ( selected index , color ) ; repaint ( ) ; } <SENTENCE_END/>

(Copy Probability: 32.4%)

<SENTENCE_START> { if ( selected index == - 1 ) return ; colors . set ( selected index , color ) ; repaint ( ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { if ( selected index == - 1 ) return ; colors . set ( selected index , color ) ; repaint ( ) ; } <SENTENCE_END/>

(Copy Probability: 3.7%)

<SENTENCE_START> { if ( selected index == - 1 ) return ; colors . set ( selected index , color ) ; repaint ( ) ; } <SENTENCE_END/>

Original Name handle,selected

handle

<SENTENCE_START> { } <SENTENCE_END/>

(Copy Probability: 0.1%)

<SENTENCE_START> { } <SENTENCE_END/>

selected

<SENTENCE_START> { } <SENTENCE_END/>

(Copy Probability: 0.0%)

<SENTENCE_START> { } <SENTENCE_END/>

%END%

<SENTENCE_START> { } <SENTENCE_END/>

(Copy Probability: 0.1%)

<SENTENCE_START> { } <SENTENCE_END/>

Original Name paint,component

paint

<SENTENCE_START> { super . %SELF% ( graphics ) ; graphics 2 d g = ( graphics 2 d ) graphics ; int width = get width ( ) - 1 ; int height = get height ( ) ; gradient width = width - handle width ; gradient height = height - 16 ; g . translate ( gradient x , gradient y ) ; for ( int i = 0 , n = colors . size ( ) == 1 ? 1 : colors . size ( ) - 1 ; i < n ; i ++ ) { color color 1 = colors . get ( i ) ; color color 2 = colors . size ( ) == 1 ? color 1 : colors . get ( i + 1 ) ; float percent 1 = percentages . get ( i ) ; float percent 2 = colors . size ( ) == 1 ? 1 : percentages . get ( i + 1 ) ; int point 1 = ( int ) ( percent 1 * gradient width ) ; int point 2 = ( int ) math . ceil ( percent 2 * gradient width ) ; g . set paint ( new gradient paint ( point 1 , 0 , color 1 , point 2 , 0 , color 2 , false ) ) ; g . fill rect ( point 1 , 0 , point 2 - point 1 , gradient height ) ; } g . set paint ( null ) ; g . set color ( color . black ) ; g . draw rect ( 0 , 0 , gradient width , gradient height ) ; int y = gradient height ; int [ ] y points = new int [ 3 ] ; y points [ 0 ] = y ; y points [ 1 ] = y + handle height ; y points [ 2 ] = y + handle height ; int [ ] x points = new int [ 3 ] ; for ( int i = 0 , n = colors . size ( ) ; i < n ; i ++ ) { int x = ( int ) ( percentages . get ( i ) * gradient width ) ; x points [ 0 ] = x ; x points [ 1 ] = x - handle width / 2 ; x points [ 2 ] = x + handle width / 2 ; if ( i == selected index ) { g . set color ( colors . get ( i ) ) ; g . fill polygon ( x points , y points , 3 ) ; g . fill rect ( x points [ 1 ] , y points [ 1 ] + 2 , handle width + 1 , 2 ) ; g . set color ( color . black ) ; } g . draw polygon ( x points , y points , 3 ) ; } g . translate ( - gradient x , - gradient y ) ; } <SENTENCE_END/>

(Copy Probability: 3.4%)

<SENTENCE_START> { super . %SELF% ( graphics ) ; graphics 2 d g = ( graphics 2 d ) graphics ; int width = get width ( ) - 1 ; int height = get height ( ) ; gradient width = width - handle width ; gradient height = height - 16 ; g . translate ( gradient x , gradient y ) ; for ( int i = 0 , n = colors . size ( ) == 1 ? 1 : colors . size ( ) - 1 ; i < n ; i ++ ) { color color 1 = colors . get ( i ) ; color color 2 = colors . size ( ) == 1 ? color 1 : colors . get ( i + 1 ) ; float percent 1 = percentages . get ( i ) ; float percent 2 = colors . size ( ) == 1 ? 1 : percentages . get ( i + 1 ) ; int point 1 = ( int ) ( percent 1 * gradient width ) ; int point 2 = ( int ) math . ceil ( percent 2 * gradient width ) ; g . set paint ( new gradient paint ( point 1 , 0 , color 1 , point 2 , 0 , color 2 , false ) ) ; g . fill rect ( point 1 , 0 , point 2 - point 1 , gradient height ) ; } g . set paint ( null ) ; g . set color ( color . black ) ; g . draw rect ( 0 , 0 , gradient width , gradient height ) ; int y = gradient height ; int [ ] y points = new int [ 3 ] ; y points [ 0 ] = y ; y points [ 1 ] = y + handle height ; y points [ 2 ] = y + handle height ; int [ ] x points = new int [ 3 ] ; for ( int i = 0 , n = colors . size ( ) ; i < n ; i ++ ) { int x = ( int ) ( percentages . get ( i ) * gradient width ) ; x points [ 0 ] = x ; x points [ 1 ] = x - handle width / 2 ; x points [ 2 ] = x + handle width / 2 ; if ( i == selected index ) { g . set color ( colors . get ( i ) ) ; g . fill polygon ( x points , y points , 3 ) ; g . fill rect ( x points [ 1 ] , y points [ 1 ] + 2 , handle width + 1 , 2 ) ; g . set color ( color . black ) ; } g . draw polygon ( x points , y points , 3 ) ; } g . translate ( - gradient x , - gradient y ) ; } <SENTENCE_END/>

component

<SENTENCE_START> { super . %SELF% ( graphics ) ; graphics 2 d g = ( graphics 2 d ) graphics ; int width = get width ( ) - 1 ; int height = get height ( ) ; gradient width = width - handle width ; gradient height = height - 16 ; g . translate ( gradient x , gradient y ) ; for ( int i = 0 , n = colors . size ( ) == 1 ? 1 : colors . size ( ) - 1 ; i < n ; i ++ ) { color color 1 = colors . get ( i ) ; color color 2 = colors . size ( ) == 1 ? color 1 : colors . get ( i + 1 ) ; float percent 1 = percentages . get ( i ) ; float percent 2 = colors . size ( ) == 1 ? 1 : percentages . get ( i + 1 ) ; int point 1 = ( int ) ( percent 1 * gradient width ) ; int point 2 = ( int ) math . ceil ( percent 2 * gradient width ) ; g . set paint ( new gradient paint ( point 1 , 0 , color 1 , point 2 , 0 , color 2 , false ) ) ; g . fill rect ( point 1 , 0 , point 2 - point 1 , gradient height ) ; } g . set paint ( null ) ; g . set color ( color . black ) ; g . draw rect ( 0 , 0 , gradient width , gradient height ) ; int y = gradient height ; int [ ] y points = new int [ 3 ] ; y points [ 0 ] = y ; y points [ 1 ] = y + handle height ; y points [ 2 ] = y + handle height ; int [ ] x points = new int [ 3 ] ; for ( int i = 0 , n = colors . size ( ) ; i < n ; i ++ ) { int x = ( int ) ( percentages . get ( i ) * gradient width ) ; x points [ 0 ] = x ; x points [ 1 ] = x - handle width / 2 ; x points [ 2 ] = x + handle width / 2 ; if ( i == selected index ) { g . set color ( colors . get ( i ) ) ; g . fill polygon ( x points , y points , 3 ) ; g . fill rect ( x points [ 1 ] , y points [ 1 ] + 2 , handle width + 1 , 2 ) ; g . set color ( color . black ) ; } g . draw polygon ( x points , y points , 3 ) ; } g . translate ( - gradient x , - gradient y ) ; } <SENTENCE_END/>

(Copy Probability: 6.0%)

<SENTENCE_START> { super . %SELF% ( graphics ) ; graphics 2 d g = ( graphics 2 d ) graphics ; int width = get width ( ) - 1 ; int height = get height ( ) ; gradient width = width - handle width ; gradient height = height - 16 ; g . translate ( gradient x , gradient y ) ; for ( int i = 0 , n = colors . size ( ) == 1 ? 1 : colors . size ( ) - 1 ; i < n ; i ++ ) { color color 1 = colors . get ( i ) ; color color 2 = colors . size ( ) == 1 ? color 1 : colors . get ( i + 1 ) ; float percent 1 = percentages . get ( i ) ; float percent 2 = colors . size ( ) == 1 ? 1 : percentages . get ( i + 1 ) ; int point 1 = ( int ) ( percent 1 * gradient width ) ; int point 2 = ( int ) math . ceil ( percent 2 * gradient width ) ; g . set paint ( new gradient paint ( point 1 , 0 , color 1 , point 2 , 0 , color 2 , false ) ) ; g . fill rect ( point 1 , 0 , point 2 - point 1 , gradient height ) ; } g . set paint ( null ) ; g . set color ( color . black ) ; g . draw rect ( 0 , 0 , gradient width , gradient height ) ; int y = gradient height ; int [ ] y points = new int [ 3 ] ; y points [ 0 ] = y ; y points [ 1 ] = y + handle height ; y points [ 2 ] = y + handle height ; int [ ] x points = new int [ 3 ] ; for ( int i = 0 , n = colors . size ( ) ; i < n ; i ++ ) { int x = ( int ) ( percentages . get ( i ) * gradient width ) ; x points [ 0 ] = x ; x points [ 1 ] = x - handle width / 2 ; x points [ 2 ] = x + handle width / 2 ; if ( i == selected index ) { g . set color ( colors . get ( i ) ) ; g . fill polygon ( x points , y points , 3 ) ; g . fill rect ( x points [ 1 ] , y points [ 1 ] + 2 , handle width + 1 , 2 ) ; g . set color ( color . black ) ; } g . draw polygon ( x points , y points , 3 ) ; } g . translate ( - gradient x , - gradient y ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { super . %SELF% ( graphics ) ; graphics 2 d g = ( graphics 2 d ) graphics ; int width = get width ( ) - 1 ; int height = get height ( ) ; gradient width = width - handle width ; gradient height = height - 16 ; g . translate ( gradient x , gradient y ) ; for ( int i = 0 , n = colors . size ( ) == 1 ? 1 : colors . size ( ) - 1 ; i < n ; i ++ ) { color color 1 = colors . get ( i ) ; color color 2 = colors . size ( ) == 1 ? color 1 : colors . get ( i + 1 ) ; float percent 1 = percentages . get ( i ) ; float percent 2 = colors . size ( ) == 1 ? 1 : percentages . get ( i + 1 ) ; int point 1 = ( int ) ( percent 1 * gradient width ) ; int point 2 = ( int ) math . ceil ( percent 2 * gradient width ) ; g . set paint ( new gradient paint ( point 1 , 0 , color 1 , point 2 , 0 , color 2 , false ) ) ; g . fill rect ( point 1 , 0 , point 2 - point 1 , gradient height ) ; } g . set paint ( null ) ; g . set color ( color . black ) ; g . draw rect ( 0 , 0 , gradient width , gradient height ) ; int y = gradient height ; int [ ] y points = new int [ 3 ] ; y points [ 0 ] = y ; y points [ 1 ] = y + handle height ; y points [ 2 ] = y + handle height ; int [ ] x points = new int [ 3 ] ; for ( int i = 0 , n = colors . size ( ) ; i < n ; i ++ ) { int x = ( int ) ( percentages . get ( i ) * gradient width ) ; x points [ 0 ] = x ; x points [ 1 ] = x - handle width / 2 ; x points [ 2 ] = x + handle width / 2 ; if ( i == selected index ) { g . set color ( colors . get ( i ) ) ; g . fill polygon ( x points , y points , 3 ) ; g . fill rect ( x points [ 1 ] , y points [ 1 ] + 2 , handle width + 1 , 2 ) ; g . set color ( color . black ) ; } g . draw polygon ( x points , y points , 3 ) ; } g . translate ( - gradient x , - gradient y ) ; } <SENTENCE_END/>

(Copy Probability: 3.9%)

<SENTENCE_START> { super . %SELF% ( graphics ) ; graphics 2 d g = ( graphics 2 d ) graphics ; int width = get width ( ) - 1 ; int height = get height ( ) ; gradient width = width - handle width ; gradient height = height - 16 ; g . translate ( gradient x , gradient y ) ; for ( int i = 0 , n = colors . size ( ) == 1 ? 1 : colors . size ( ) - 1 ; i < n ; i ++ ) { color color 1 = colors . get ( i ) ; color color 2 = colors . size ( ) == 1 ? color 1 : colors . get ( i + 1 ) ; float percent 1 = percentages . get ( i ) ; float percent 2 = colors . size ( ) == 1 ? 1 : percentages . get ( i + 1 ) ; int point 1 = ( int ) ( percent 1 * gradient width ) ; int point 2 = ( int ) math . ceil ( percent 2 * gradient width ) ; g . set paint ( new gradient paint ( point 1 , 0 , color 1 , point 2 , 0 , color 2 , false ) ) ; g . fill rect ( point 1 , 0 , point 2 - point 1 , gradient height ) ; } g . set paint ( null ) ; g . set color ( color . black ) ; g . draw rect ( 0 , 0 , gradient width , gradient height ) ; int y = gradient height ; int [ ] y points = new int [ 3 ] ; y points [ 0 ] = y ; y points [ 1 ] = y + handle height ; y points [ 2 ] = y + handle height ; int [ ] x points = new int [ 3 ] ; for ( int i = 0 , n = colors . size ( ) ; i < n ; i ++ ) { int x = ( int ) ( percentages . get ( i ) * gradient width ) ; x points [ 0 ] = x ; x points [ 1 ] = x - handle width / 2 ; x points [ 2 ] = x + handle width / 2 ; if ( i == selected index ) { g . set color ( colors . get ( i ) ) ; g . fill polygon ( x points , y points , 3 ) ; g . fill rect ( x points [ 1 ] , y points [ 1 ] + 2 , handle width + 1 , 2 ) ; g . set color ( color . black ) ; } g . draw polygon ( x points , y points , 3 ) ; } g . translate ( - gradient x , - gradient y ) ; } <SENTENCE_END/>

Original Name state,changed

state

<SENTENCE_START> { color picked ( ) ; } <SENTENCE_END/>

(Copy Probability: 0.4%)

<SENTENCE_START> { color picked ( ) ; } <SENTENCE_END/>

changed

<SENTENCE_START> { color picked ( ) ; } <SENTENCE_END/>

(Copy Probability: 0.5%)

<SENTENCE_START> { color picked ( ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { color picked ( ) ; } <SENTENCE_END/>

(Copy Probability: 0.2%)

<SENTENCE_START> { color picked ( ) ; } <SENTENCE_END/>

Original Name get,preferred,size

get

<SENTENCE_START> { dimension size = super . %SELF% ( ) ; size . width = 10 ; return size ; } <SENTENCE_END/>

(Copy Probability: 0.8%)

<SENTENCE_START> { dimension size = super . %SELF% ( ) ; size . width = 10 ; return size ; } <SENTENCE_END/>

preferred

<SENTENCE_START> { dimension size = super . %SELF% ( ) ; size . width = 10 ; return size ; } <SENTENCE_END/>

(Copy Probability: 5.0%)

<SENTENCE_START> { dimension size = super . %SELF% ( ) ; size . width = 10 ; return size ; } <SENTENCE_END/>

size

<SENTENCE_START> { dimension size = super . %SELF% ( ) ; size . width = 10 ; return size ; } <SENTENCE_END/>

(Copy Probability: 1.3%)

<SENTENCE_START> { dimension size = super . %SELF% ( ) ; size . width = 10 ; return size ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { dimension size = super . %SELF% ( ) ; size . width = 10 ; return size ; } <SENTENCE_END/>

(Copy Probability: 1.9%)

<SENTENCE_START> { dimension size = super . %SELF% ( ) ; size . width = 10 ; return size ; } <SENTENCE_END/>

Original Name set,percentage

set

<SENTENCE_START> { slider . set value ( ( int ) ( 1000 * percent ) ) ; } <SENTENCE_END/>

(Copy Probability: 0.8%)

<SENTENCE_START> { slider . set value ( ( int ) ( 1000 * percent ) ) ; } <SENTENCE_END/>

percentage

<SENTENCE_START> { slider . set value ( ( int ) ( 1000 * percent ) ) ; } <SENTENCE_END/>

(Copy Probability: 2.6%)

<SENTENCE_START> { slider . set value ( ( int ) ( 1000 * percent ) ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { slider . set value ( ( int ) ( 1000 * percent ) ) ; } <SENTENCE_END/>

(Copy Probability: 0.4%)

<SENTENCE_START> { slider . set value ( ( int ) ( 1000 * percent ) ) ; } <SENTENCE_END/>

Original Name get,percentage

get

<SENTENCE_START> { return slider . get value ( ) / 1000f ; } <SENTENCE_END/>

(Copy Probability: 0.5%)

<SENTENCE_START> { return slider . get value ( ) / 1000f ; } <SENTENCE_END/>

percentage

<SENTENCE_START> { return slider . get value ( ) / 1000f ; } <SENTENCE_END/>

(Copy Probability: 2.9%)

<SENTENCE_START> { return slider . get value ( ) / 1000f ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return slider . get value ( ) / 1000f ; } <SENTENCE_END/>

(Copy Probability: 1.8%)

<SENTENCE_START> { return slider . get value ( ) / 1000f ; } <SENTENCE_END/>

Original Name color,picked

color

<SENTENCE_START> { } <SENTENCE_END/>

(Copy Probability: 0.1%)

<SENTENCE_START> { } <SENTENCE_END/>

picked

<SENTENCE_START> { } <SENTENCE_END/>

(Copy Probability: 0.0%)

<SENTENCE_START> { } <SENTENCE_END/>

%END%

<SENTENCE_START> { } <SENTENCE_END/>

(Copy Probability: 0.1%)

<SENTENCE_START> { } <SENTENCE_END/>

Original Name set,colors

set

<SENTENCE_START> { palette colors = colors ; repaint ( ) ; } <SENTENCE_END/>

(Copy Probability: 0.6%)

<SENTENCE_START> { palette colors = colors ; repaint ( ) ; } <SENTENCE_END/>

colors

<SENTENCE_START> { palette colors = colors ; repaint ( ) ; } <SENTENCE_END/>

(Copy Probability: 34.2%)

<SENTENCE_START> { palette colors = colors ; repaint ( ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { palette colors = colors ; repaint ( ) ; } <SENTENCE_END/>

(Copy Probability: 1.1%)

<SENTENCE_START> { palette colors = colors ; repaint ( ) ; } <SENTENCE_END/>

Original Name mouse,clicked

mouse

<SENTENCE_START> { slider . set value ( ( int ) ( event . get x ( ) / ( float ) get width ( ) * 1000 ) ) ; } <SENTENCE_END/>

(Copy Probability: 1.3%)

<SENTENCE_START> { slider . set value ( ( int ) ( event . get x ( ) / ( float ) get width ( ) * 1000 ) ) ; } <SENTENCE_END/>

clicked

<SENTENCE_START> { slider . set value ( ( int ) ( event . get x ( ) / ( float ) get width ( ) * 1000 ) ) ; } <SENTENCE_END/>

(Copy Probability: 5.2%)

<SENTENCE_START> { slider . set value ( ( int ) ( event . get x ( ) / ( float ) get width ( ) * 1000 ) ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { slider . set value ( ( int ) ( event . get x ( ) / ( float ) get width ( ) * 1000 ) ) ; } <SENTENCE_END/>

(Copy Probability: 1.3%)

<SENTENCE_START> { slider . set value ( ( int ) ( event . get x ( ) / ( float ) get width ( ) * 1000 ) ) ; } <SENTENCE_END/>

Original Name paint,component

paint

<SENTENCE_START> { graphics 2 d g = ( graphics 2 d ) graphics ; int width = get width ( ) - 1 ; int height = get height ( ) - 1 ; for ( int i = 0 , n = palette colors . length - 1 ; i < n ; i ++ ) { color color 1 = palette colors [ i ] ; color color 2 = palette colors [ i + 1 ] ; float point 1 = i / ( float ) n * width ; float point 2 = ( i + 1 ) / ( float ) n * width ; g . set paint ( new gradient paint ( point 1 , 0 , color 1 , point 2 , 0 , color 2 , false ) ) ; g . fill rect ( ( int ) point 1 , 0 , ( int ) math . ceil ( point 2 - point 1 ) , height ) ; } g . set paint ( null ) ; g . set color ( color . black ) ; g . draw rect ( 0 , 0 , width , height ) ; } <SENTENCE_END/>

(Copy Probability: 3.6%)

<SENTENCE_START> { graphics 2 d g = ( graphics 2 d ) graphics ; int width = get width ( ) - 1 ; int height = get height ( ) - 1 ; for ( int i = 0 , n = palette colors . length - 1 ; i < n ; i ++ ) { color color 1 = palette colors [ i ] ; color color 2 = palette colors [ i + 1 ] ; float point 1 = i / ( float ) n * width ; float point 2 = ( i + 1 ) / ( float ) n * width ; g . set paint ( new gradient paint ( point 1 , 0 , color 1 , point 2 , 0 , color 2 , false ) ) ; g . fill rect ( ( int ) point 1 , 0 , ( int ) math . ceil ( point 2 - point 1 ) , height ) ; } g . set paint ( null ) ; g . set color ( color . black ) ; g . draw rect ( 0 , 0 , width , height ) ; } <SENTENCE_END/>

component

<SENTENCE_START> { graphics 2 d g = ( graphics 2 d ) graphics ; int width = get width ( ) - 1 ; int height = get height ( ) - 1 ; for ( int i = 0 , n = palette colors . length - 1 ; i < n ; i ++ ) { color color 1 = palette colors [ i ] ; color color 2 = palette colors [ i + 1 ] ; float point 1 = i / ( float ) n * width ; float point 2 = ( i + 1 ) / ( float ) n * width ; g . set paint ( new gradient paint ( point 1 , 0 , color 1 , point 2 , 0 , color 2 , false ) ) ; g . fill rect ( ( int ) point 1 , 0 , ( int ) math . ceil ( point 2 - point 1 ) , height ) ; } g . set paint ( null ) ; g . set color ( color . black ) ; g . draw rect ( 0 , 0 , width , height ) ; } <SENTENCE_END/>

(Copy Probability: 14.1%)

<SENTENCE_START> { graphics 2 d g = ( graphics 2 d ) graphics ; int width = get width ( ) - 1 ; int height = get height ( ) - 1 ; for ( int i = 0 , n = palette colors . length - 1 ; i < n ; i ++ ) { color color 1 = palette colors [ i ] ; color color 2 = palette colors [ i + 1 ] ; float point 1 = i / ( float ) n * width ; float point 2 = ( i + 1 ) / ( float ) n * width ; g . set paint ( new gradient paint ( point 1 , 0 , color 1 , point 2 , 0 , color 2 , false ) ) ; g . fill rect ( ( int ) point 1 , 0 , ( int ) math . ceil ( point 2 - point 1 ) , height ) ; } g . set paint ( null ) ; g . set color ( color . black ) ; g . draw rect ( 0 , 0 , width , height ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { graphics 2 d g = ( graphics 2 d ) graphics ; int width = get width ( ) - 1 ; int height = get height ( ) - 1 ; for ( int i = 0 , n = palette colors . length - 1 ; i < n ; i ++ ) { color color 1 = palette colors [ i ] ; color color 2 = palette colors [ i + 1 ] ; float point 1 = i / ( float ) n * width ; float point 2 = ( i + 1 ) / ( float ) n * width ; g . set paint ( new gradient paint ( point 1 , 0 , color 1 , point 2 , 0 , color 2 , false ) ) ; g . fill rect ( ( int ) point 1 , 0 , ( int ) math . ceil ( point 2 - point 1 ) , height ) ; } g . set paint ( null ) ; g . set color ( color . black ) ; g . draw rect ( 0 , 0 , width , height ) ; } <SENTENCE_END/>

(Copy Probability: 5.2%)

<SENTENCE_START> { graphics 2 d g = ( graphics 2 d ) graphics ; int width = get width ( ) - 1 ; int height = get height ( ) - 1 ; for ( int i = 0 , n = palette colors . length - 1 ; i < n ; i ++ ) { color color 1 = palette colors [ i ] ; color color 2 = palette colors [ i + 1 ] ; float point 1 = i / ( float ) n * width ; float point 2 = ( i + 1 ) / ( float ) n * width ; g . set paint ( new gradient paint ( point 1 , 0 , color 1 , point 2 , 0 , color 2 , false ) ) ; g . fill rect ( ( int ) point 1 , 0 , ( int ) math . ceil ( point 2 - point 1 ) , height ) ; } g . set paint ( null ) ; g . set color ( color . black ) ; g . draw rect ( 0 , 0 , width , height ) ; } <SENTENCE_END/>

Original Name find,new,contacts

find

<SENTENCE_START> { m broad phase . update pairs ( this ) ; } <SENTENCE_END/>

(Copy Probability: 0.7%)

<SENTENCE_START> { m broad phase . update pairs ( this ) ; } <SENTENCE_END/>

new

<SENTENCE_START> { m broad phase . update pairs ( this ) ; } <SENTENCE_END/>

(Copy Probability: 1.5%)

<SENTENCE_START> { m broad phase . update pairs ( this ) ; } <SENTENCE_END/>

contacts

<SENTENCE_START> { m broad phase . update pairs ( this ) ; } <SENTENCE_END/>

(Copy Probability: 0.8%)

<SENTENCE_START> { m broad phase . update pairs ( this ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { m broad phase . update pairs ( this ) ; } <SENTENCE_END/>

(Copy Probability: 0.8%)

<SENTENCE_START> { m broad phase . update pairs ( this ) ; } <SENTENCE_END/>

Original Name destroy

destroy

<SENTENCE_START> { fixture fixture a = c . get fixture a ( ) ; fixture fixture b = c . get fixture b ( ) ; body body a = fixture a . get body ( ) ; body body b = fixture b . get body ( ) ; if ( m contact listener != null && c . is touching ( ) ) { m contact listener . end contact ( c ) ; } if ( c . m prev != null ) { c . m prev . m next = c . m next ; } if ( c . m next != null ) { c . m next . m prev = c . m prev ; } if ( c == m contact list ) { m contact list = c . m next ; } if ( c . m node a . prev != null ) { c . m node a . prev . next = c . m node a . next ; } if ( c . m node a . next != null ) { c . m node a . next . prev = c . m node a . prev ; } if ( c . m node a == body a . m contact list ) { body a . m contact list = c . m node a . next ; } if ( c . m node b . prev != null ) { c . m node b . prev . next = c . m node b . next ; } if ( c . m node b . next != null ) { c . m node b . next . prev = c . m node b . prev ; } if ( c . m node b == body b . m contact list ) { body b . m contact list = c . m node b . next ; } pool . push contact ( c ) ; -- m contact count ; } <SENTENCE_END/>

(Copy Probability: 4.8%)

<SENTENCE_START> { fixture fixture a = c . get fixture a ( ) ; fixture fixture b = c . get fixture b ( ) ; body body a = fixture a . get body ( ) ; body body b = fixture b . get body ( ) ; if ( m contact listener != null && c . is touching ( ) ) { m contact listener . end contact ( c ) ; } if ( c . m prev != null ) { c . m prev . m next = c . m next ; } if ( c . m next != null ) { c . m next . m prev = c . m prev ; } if ( c == m contact list ) { m contact list = c . m next ; } if ( c . m node a . prev != null ) { c . m node a . prev . next = c . m node a . next ; } if ( c . m node a . next != null ) { c . m node a . next . prev = c . m node a . prev ; } if ( c . m node a == body a . m contact list ) { body a . m contact list = c . m node a . next ; } if ( c . m node b . prev != null ) { c . m node b . prev . next = c . m node b . next ; } if ( c . m node b . next != null ) { c . m node b . next . prev = c . m node b . prev ; } if ( c . m node b == body b . m contact list ) { body b . m contact list = c . m node b . next ; } pool . push contact ( c ) ; -- m contact count ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { fixture fixture a = c . get fixture a ( ) ; fixture fixture b = c . get fixture b ( ) ; body body a = fixture a . get body ( ) ; body body b = fixture b . get body ( ) ; if ( m contact listener != null && c . is touching ( ) ) { m contact listener . end contact ( c ) ; } if ( c . m prev != null ) { c . m prev . m next = c . m next ; } if ( c . m next != null ) { c . m next . m prev = c . m prev ; } if ( c == m contact list ) { m contact list = c . m next ; } if ( c . m node a . prev != null ) { c . m node a . prev . next = c . m node a . next ; } if ( c . m node a . next != null ) { c . m node a . next . prev = c . m node a . prev ; } if ( c . m node a == body a . m contact list ) { body a . m contact list = c . m node a . next ; } if ( c . m node b . prev != null ) { c . m node b . prev . next = c . m node b . next ; } if ( c . m node b . next != null ) { c . m node b . next . prev = c . m node b . prev ; } if ( c . m node b == body b . m contact list ) { body b . m contact list = c . m node b . next ; } pool . push contact ( c ) ; -- m contact count ; } <SENTENCE_END/>

(Copy Probability: 24.4%)

<SENTENCE_START> { fixture fixture a = c . get fixture a ( ) ; fixture fixture b = c . get fixture b ( ) ; body body a = fixture a . get body ( ) ; body body b = fixture b . get body ( ) ; if ( m contact listener != null && c . is touching ( ) ) { m contact listener . end contact ( c ) ; } if ( c . m prev != null ) { c . m prev . m next = c . m next ; } if ( c . m next != null ) { c . m next . m prev = c . m prev ; } if ( c == m contact list ) { m contact list = c . m next ; } if ( c . m node a . prev != null ) { c . m node a . prev . next = c . m node a . next ; } if ( c . m node a . next != null ) { c . m node a . next . prev = c . m node a . prev ; } if ( c . m node a == body a . m contact list ) { body a . m contact list = c . m node a . next ; } if ( c . m node b . prev != null ) { c . m node b . prev . next = c . m node b . next ; } if ( c . m node b . next != null ) { c . m node b . next . prev = c . m node b . prev ; } if ( c . m node b == body b . m contact list ) { body b . m contact list = c . m node b . next ; } pool . push contact ( c ) ; -- m contact count ; } <SENTENCE_END/>

Original Name collide

collide

<SENTENCE_START> { contact c = m contact list ; while ( c != null ) { fixture fixture a = c . get fixture a ( ) ; fixture fixture b = c . get fixture b ( ) ; int index a = c . get child index a ( ) ; int index b = c . get child index b ( ) ; body body a = fixture a . get body ( ) ; body body b = fixture b . get body ( ) ; if ( ( c . m flags & contact . filter flag ) == contact . filter flag ) { if ( body b . should collide ( body a ) == false ) { contact c nuke = c ; c = c nuke . get next ( ) ; destroy ( c nuke ) ; continue ; } if ( m contact filter != null && m contact filter . should collide ( fixture a , fixture b ) == false ) { contact c nuke = c ; c = c nuke . get next ( ) ; destroy ( c nuke ) ; continue ; } c . m flags &= ~ contact . filter flag ; } boolean active a = body a . is awake ( ) && body a . m type != body type . static ; boolean active b = body b . is awake ( ) && body b . m type != body type . static ; if ( active a == false && active b == false ) { c = c . get next ( ) ; continue ; } int proxy id a = fixture a . m proxies [ index a ] . proxy id ; int proxy id b = fixture b . m proxies [ index b ] . proxy id ; boolean overlap = m broad phase . test overlap ( proxy id a , proxy id b ) ; if ( overlap == false ) { contact c nuke = c ; c = c nuke . get next ( ) ; destroy ( c nuke ) ; continue ; } c . update ( m contact listener ) ; c = c . get next ( ) ; } } <SENTENCE_END/>

(Copy Probability: 5.1%)

<SENTENCE_START> { contact c = m contact list ; while ( c != null ) { fixture fixture a = c . get fixture a ( ) ; fixture fixture b = c . get fixture b ( ) ; int index a = c . get child index a ( ) ; int index b = c . get child index b ( ) ; body body a = fixture a . get body ( ) ; body body b = fixture b . get body ( ) ; if ( ( c . m flags & contact . filter flag ) == contact . filter flag ) { if ( body b . should collide ( body a ) == false ) { contact c nuke = c ; c = c nuke . get next ( ) ; destroy ( c nuke ) ; continue ; } if ( m contact filter != null && m contact filter . should collide ( fixture a , fixture b ) == false ) { contact c nuke = c ; c = c nuke . get next ( ) ; destroy ( c nuke ) ; continue ; } c . m flags &= ~ contact . filter flag ; } boolean active a = body a . is awake ( ) && body a . m type != body type . static ; boolean active b = body b . is awake ( ) && body b . m type != body type . static ; if ( active a == false && active b == false ) { c = c . get next ( ) ; continue ; } int proxy id a = fixture a . m proxies [ index a ] . proxy id ; int proxy id b = fixture b . m proxies [ index b ] . proxy id ; boolean overlap = m broad phase . test overlap ( proxy id a , proxy id b ) ; if ( overlap == false ) { contact c nuke = c ; c = c nuke . get next ( ) ; destroy ( c nuke ) ; continue ; } c . update ( m contact listener ) ; c = c . get next ( ) ; } } <SENTENCE_END/>

%END%

<SENTENCE_START> { contact c = m contact list ; while ( c != null ) { fixture fixture a = c . get fixture a ( ) ; fixture fixture b = c . get fixture b ( ) ; int index a = c . get child index a ( ) ; int index b = c . get child index b ( ) ; body body a = fixture a . get body ( ) ; body body b = fixture b . get body ( ) ; if ( ( c . m flags & contact . filter flag ) == contact . filter flag ) { if ( body b . should collide ( body a ) == false ) { contact c nuke = c ; c = c nuke . get next ( ) ; destroy ( c nuke ) ; continue ; } if ( m contact filter != null && m contact filter . should collide ( fixture a , fixture b ) == false ) { contact c nuke = c ; c = c nuke . get next ( ) ; destroy ( c nuke ) ; continue ; } c . m flags &= ~ contact . filter flag ; } boolean active a = body a . is awake ( ) && body a . m type != body type . static ; boolean active b = body b . is awake ( ) && body b . m type != body type . static ; if ( active a == false && active b == false ) { c = c . get next ( ) ; continue ; } int proxy id a = fixture a . m proxies [ index a ] . proxy id ; int proxy id b = fixture b . m proxies [ index b ] . proxy id ; boolean overlap = m broad phase . test overlap ( proxy id a , proxy id b ) ; if ( overlap == false ) { contact c nuke = c ; c = c nuke . get next ( ) ; destroy ( c nuke ) ; continue ; } c . update ( m contact listener ) ; c = c . get next ( ) ; } } <SENTENCE_END/>

(Copy Probability: 18.1%)

<SENTENCE_START> { contact c = m contact list ; while ( c != null ) { fixture fixture a = c . get fixture a ( ) ; fixture fixture b = c . get fixture b ( ) ; int index a = c . get child index a ( ) ; int index b = c . get child index b ( ) ; body body a = fixture a . get body ( ) ; body body b = fixture b . get body ( ) ; if ( ( c . m flags & contact . filter flag ) == contact . filter flag ) { if ( body b . should collide ( body a ) == false ) { contact c nuke = c ; c = c nuke . get next ( ) ; destroy ( c nuke ) ; continue ; } if ( m contact filter != null && m contact filter . should collide ( fixture a , fixture b ) == false ) { contact c nuke = c ; c = c nuke . get next ( ) ; destroy ( c nuke ) ; continue ; } c . m flags &= ~ contact . filter flag ; } boolean active a = body a . is awake ( ) && body a . m type != body type . static ; boolean active b = body b . is awake ( ) && body b . m type != body type . static ; if ( active a == false && active b == false ) { c = c . get next ( ) ; continue ; } int proxy id a = fixture a . m proxies [ index a ] . proxy id ; int proxy id b = fixture b . m proxies [ index b ] . proxy id ; boolean overlap = m broad phase . test overlap ( proxy id a , proxy id b ) ; if ( overlap == false ) { contact c nuke = c ; c = c nuke . get next ( ) ; destroy ( c nuke ) ; continue ; } c . update ( m contact listener ) ; c = c . get next ( ) ; } } <SENTENCE_END/>

Original Name get,c,ptr

get

<SENTENCE_START> { return ( obj == null ) ? 0 : obj . swig c ptr ; } <SENTENCE_END/>

(Copy Probability: 1.5%)

<SENTENCE_START> { return ( obj == null ) ? 0 : obj . swig c ptr ; } <SENTENCE_END/>

c

<SENTENCE_START> { return ( obj == null ) ? 0 : obj . swig c ptr ; } <SENTENCE_END/>

(Copy Probability: 99.7%)

<SENTENCE_START> { return ( obj == null ) ? 0 : obj . swig c ptr ; } <SENTENCE_END/>

ptr

<SENTENCE_START> { return ( obj == null ) ? 0 : obj . swig c ptr ; } <SENTENCE_END/>

(Copy Probability: 99.8%)

<SENTENCE_START> { return ( obj == null ) ? 0 : obj . swig c ptr ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return ( obj == null ) ? 0 : obj . swig c ptr ; } <SENTENCE_END/>

(Copy Probability: 3.7%)

<SENTENCE_START> { return ( obj == null ) ? 0 : obj . swig c ptr ; } <SENTENCE_END/>

Original Name set,contact,manifold

set

<SENTENCE_START> { dynamics jni . bt contact constraint set contact manifold ( swig c ptr , this , bt persistent manifold . get c ptr ( contact manifold ) , contact manifold ) ; } <SENTENCE_END/>

(Copy Probability: 6.1%)

<SENTENCE_START> { dynamics jni . bt contact constraint set contact manifold ( swig c ptr , this , bt persistent manifold . get c ptr ( contact manifold ) , contact manifold ) ; } <SENTENCE_END/>

contact

<SENTENCE_START> { dynamics jni . bt contact constraint set contact manifold ( swig c ptr , this , bt persistent manifold . get c ptr ( contact manifold ) , contact manifold ) ; } <SENTENCE_END/>

(Copy Probability: 99.7%)

<SENTENCE_START> { dynamics jni . bt contact constraint set contact manifold ( swig c ptr , this , bt persistent manifold . get c ptr ( contact manifold ) , contact manifold ) ; } <SENTENCE_END/>

manifold

<SENTENCE_START> { dynamics jni . bt contact constraint set contact manifold ( swig c ptr , this , bt persistent manifold . get c ptr ( contact manifold ) , contact manifold ) ; } <SENTENCE_END/>

(Copy Probability: 99.4%)

<SENTENCE_START> { dynamics jni . bt contact constraint set contact manifold ( swig c ptr , this , bt persistent manifold . get c ptr ( contact manifold ) , contact manifold ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { dynamics jni . bt contact constraint set contact manifold ( swig c ptr , this , bt persistent manifold . get c ptr ( contact manifold ) , contact manifold ) ; } <SENTENCE_END/>

(Copy Probability: 9.9%)

<SENTENCE_START> { dynamics jni . bt contact constraint set contact manifold ( swig c ptr , this , bt persistent manifold . get c ptr ( contact manifold ) , contact manifold ) ; } <SENTENCE_END/>

Original Name get,contact,manifold

get

<SENTENCE_START> { long c ptr = dynamics jni . bt contact constraint get contact manifold swig 0 ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt persistent manifold ( c ptr , false ) ; } <SENTENCE_END/>

(Copy Probability: 5.7%)

<SENTENCE_START> { long c ptr = dynamics jni . bt contact constraint get contact manifold swig 0 ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt persistent manifold ( c ptr , false ) ; } <SENTENCE_END/>

contact

<SENTENCE_START> { long c ptr = dynamics jni . bt contact constraint get contact manifold swig 0 ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt persistent manifold ( c ptr , false ) ; } <SENTENCE_END/>

(Copy Probability: 99.8%)

<SENTENCE_START> { long c ptr = dynamics jni . bt contact constraint get contact manifold swig 0 ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt persistent manifold ( c ptr , false ) ; } <SENTENCE_END/>

manifold

<SENTENCE_START> { long c ptr = dynamics jni . bt contact constraint get contact manifold swig 0 ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt persistent manifold ( c ptr , false ) ; } <SENTENCE_END/>

(Copy Probability: 99.8%)

<SENTENCE_START> { long c ptr = dynamics jni . bt contact constraint get contact manifold swig 0 ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt persistent manifold ( c ptr , false ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { long c ptr = dynamics jni . bt contact constraint get contact manifold swig 0 ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt persistent manifold ( c ptr , false ) ; } <SENTENCE_END/>

(Copy Probability: 28.6%)

<SENTENCE_START> { long c ptr = dynamics jni . bt contact constraint get contact manifold swig 0 ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt persistent manifold ( c ptr , false ) ; } <SENTENCE_END/>

Original Name pack

pack

<SENTENCE_START> { for ( int i = 0 , nn = input rects . size ; i < nn ; i ++ ) { rect rect = input rects . get ( i ) ; rect . width += settings . padding x ; rect . height += settings . padding y ; } if ( settings . fast ) { if ( settings . rotation ) { sort . sort ( input rects , new comparator < rect > ( ) { public int compare ( rect o 1 , rect o 2 ) { int n 1 = o 1 . width > o 1 . height ? o 1 . width : o 1 . height ; int n 2 = o 2 . width > o 2 . height ? o 2 . width : o 2 . height ; return n 2 - n 1 ; } } ) ; } else { sort . sort ( input rects , new comparator < rect > ( ) { public int compare ( rect o 1 , rect o 2 ) { return o 2 . width - o 1 . width ; } } ) ; } } array < page > pages = new array ( ) ; while ( input rects . size > 0 ) { page result = pack page ( input rects ) ; pages . add ( result ) ; input rects = result . remaining rects ; } return pages ; } <SENTENCE_END/>

(Copy Probability: 3.6%)

<SENTENCE_START> { for ( int i = 0 , nn = input rects . size ; i < nn ; i ++ ) { rect rect = input rects . get ( i ) ; rect . width += settings . padding x ; rect . height += settings . padding y ; } if ( settings . fast ) { if ( settings . rotation ) { sort . sort ( input rects , new comparator < rect > ( ) { public int compare ( rect o 1 , rect o 2 ) { int n 1 = o 1 . width > o 1 . height ? o 1 . width : o 1 . height ; int n 2 = o 2 . width > o 2 . height ? o 2 . width : o 2 . height ; return n 2 - n 1 ; } } ) ; } else { sort . sort ( input rects , new comparator < rect > ( ) { public int compare ( rect o 1 , rect o 2 ) { return o 2 . width - o 1 . width ; } } ) ; } } array < page > pages = new array ( ) ; while ( input rects . size > 0 ) { page result = pack page ( input rects ) ; pages . add ( result ) ; input rects = result . remaining rects ; } return pages ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { for ( int i = 0 , nn = input rects . size ; i < nn ; i ++ ) { rect rect = input rects . get ( i ) ; rect . width += settings . padding x ; rect . height += settings . padding y ; } if ( settings . fast ) { if ( settings . rotation ) { sort . sort ( input rects , new comparator < rect > ( ) { public int compare ( rect o 1 , rect o 2 ) { int n 1 = o 1 . width > o 1 . height ? o 1 . width : o 1 . height ; int n 2 = o 2 . width > o 2 . height ? o 2 . width : o 2 . height ; return n 2 - n 1 ; } } ) ; } else { sort . sort ( input rects , new comparator < rect > ( ) { public int compare ( rect o 1 , rect o 2 ) { return o 2 . width - o 1 . width ; } } ) ; } } array < page > pages = new array ( ) ; while ( input rects . size > 0 ) { page result = pack page ( input rects ) ; pages . add ( result ) ; input rects = result . remaining rects ; } return pages ; } <SENTENCE_END/>

(Copy Probability: 6.6%)

<SENTENCE_START> { for ( int i = 0 , nn = input rects . size ; i < nn ; i ++ ) { rect rect = input rects . get ( i ) ; rect . width += settings . padding x ; rect . height += settings . padding y ; } if ( settings . fast ) { if ( settings . rotation ) { sort . sort ( input rects , new comparator < rect > ( ) { public int compare ( rect o 1 , rect o 2 ) { int n 1 = o 1 . width > o 1 . height ? o 1 . width : o 1 . height ; int n 2 = o 2 . width > o 2 . height ? o 2 . width : o 2 . height ; return n 2 - n 1 ; } } ) ; } else { sort . sort ( input rects , new comparator < rect > ( ) { public int compare ( rect o 1 , rect o 2 ) { return o 2 . width - o 1 . width ; } } ) ; } } array < page > pages = new array ( ) ; while ( input rects . size > 0 ) { page result = pack page ( input rects ) ; pages . add ( result ) ; input rects = result . remaining rects ; } return pages ; } <SENTENCE_END/>

Original Name compare

compare

<SENTENCE_START> { int n 1 = o 1 . width > o 1 . height ? o 1 . width : o 1 . height ; int n 2 = o 2 . width > o 2 . height ? o 2 . width : o 2 . height ; return n 2 - n 1 ; } <SENTENCE_END/>

(Copy Probability: 1.6%)

<SENTENCE_START> { int n 1 = o 1 . width > o 1 . height ? o 1 . width : o 1 . height ; int n 2 = o 2 . width > o 2 . height ? o 2 . width : o 2 . height ; return n 2 - n 1 ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { int n 1 = o 1 . width > o 1 . height ? o 1 . width : o 1 . height ; int n 2 = o 2 . width > o 2 . height ? o 2 . width : o 2 . height ; return n 2 - n 1 ; } <SENTENCE_END/>

(Copy Probability: 1.9%)

<SENTENCE_START> { int n 1 = o 1 . width > o 1 . height ? o 1 . width : o 1 . height ; int n 2 = o 2 . width > o 2 . height ? o 2 . width : o 2 . height ; return n 2 - n 1 ; } <SENTENCE_END/>

Original Name compare

compare

<SENTENCE_START> { return o 2 . width - o 1 . width ; } <SENTENCE_END/>

(Copy Probability: 0.4%)

<SENTENCE_START> { return o 2 . width - o 1 . width ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return o 2 . width - o 1 . width ; } <SENTENCE_END/>

(Copy Probability: 0.2%)

<SENTENCE_START> { return o 2 . width - o 1 . width ; } <SENTENCE_END/>

Original Name pack,page

pack

<SENTENCE_START> { int padding x = settings . padding x , padding y = settings . padding y ; float max width = settings . max width , max height = settings . max height ; int edge padding x = 0 , edge padding y = 0 ; if ( settings . edge padding ) { if ( settings . duplicate padding ) { max width -= padding x ; max height -= padding y ; } else { max width -= padding x * 2 ; max height -= padding y * 2 ; edge padding x = padding x ; edge padding y = padding y ; } } int min width = integer . max value , min height = integer . max value ; for ( int i = 0 , nn = input rects . size ; i < nn ; i ++ ) { rect rect = input rects . get ( i ) ; min width = math . min ( min width , rect . width ) ; min height = math . min ( min height , rect . height ) ; float width = rect . width - padding x , height = rect . height - padding y ; if ( settings . rotation ) { if ( ( width > max width || height > max height ) && ( width > max height || height > max width ) ) { string padding message = ( edge padding x > 0 || edge padding y > 0 ) ? ( " and edge padding " + padding x + "," + padding y ) : "" ; throw new runtime exception ( "Image does not fit with max page size " + settings . max width + "x" + settings . max height + padding message + ": " + rect . name + "[" + width + "," + height + "]" ) ; } } else { if ( width > max width ) { string padding message = edge padding x > 0 ? ( " and X edge padding " + padding x ) : "" ; throw new runtime exception ( "Image does not fit with max page width " + settings . max width + padding message + ": " + rect . name + "[" + width + "," + height + "]" ) ; } if ( height > max height && ( ! settings . rotation || width > max height ) ) { string padding message = edge padding y > 0 ? ( " and Y edge padding " + padding y ) : "" ; throw new runtime exception ( "Image does not fit in max page height " + settings . max height + padding message + ": " + rect . name + "[" + width + "," + height + "]" ) ; } } } min width = math . max ( min width , settings . min width ) ; min height = math . max ( min height , settings . min height ) ; if ( ! settings . silent ) system . out . print ( "Packing" ) ; page best result = null ; if ( settings . square ) { int min size = math . max ( min width , min height ) ; int max size = math . min ( settings . max width , settings . max height ) ; binary search size search = new binary search ( min size , max size , settings . fast ? 25 : 15 , settings . pot ) ; int size = size search . reset ( ) , i = 0 ; while ( size != - 1 ) { page result = pack at size ( true , size - edge padding x , size - edge padding y , input rects ) ; if ( ! settings . silent ) { if ( ++ i % 70 == 0 ) system . out . println ( ) ; system . out . print ( "." ) ; } best result = get best ( best result , result ) ; size = size search . next ( result == null ) ; } if ( ! settings . silent ) system . out . println ( ) ; if ( best result == null ) best result = pack at size ( false , max size - edge padding x , max size - edge padding y , input rects ) ; sort . sort ( best result . output rects , rect comparator ) ; best result . width = math . max ( best result . width , best result . height ) ; best result . height = math . max ( best result . width , best result . height ) ; return best result ; } else { binary search width search = new binary search ( min width , settings . max width , settings . fast ? 25 : 15 , settings . pot ) ; binary search height search = new binary search ( min height , settings . max height , settings . fast ? 25 : 15 , settings . pot ) ; int width = width search . reset ( ) , i = 0 ; int height = settings . square ? width : height search . reset ( ) ; while ( true ) { page best width result = null ; while ( width != - 1 ) { page result = pack at size ( true , width - edge padding x , height - edge padding y , input rects ) ; if ( ! settings . silent ) { if ( ++ i % 70 == 0 ) system . out . println ( ) ; system . out . print ( "." ) ; } best width result = get best ( best width result , result ) ; width = width search . next ( result == null ) ; if ( settings . square ) height = width ; } best result = get best ( best result , best width result ) ; if ( settings . square ) break ; height = height search . next ( best width result == null ) ; if ( height == - 1 ) break ; width = width search . reset ( ) ; } if ( ! settings . silent ) system . out . println ( ) ; if ( best result == null ) best result = pack at size ( false , settings . max width - edge padding x , settings . max height - edge padding y , input rects ) ; sort . sort ( best result . output rects , rect comparator ) ; return best result ; } } <SENTENCE_END/>

(Copy Probability: 3.4%)

<SENTENCE_START> { int padding x = settings . padding x , padding y = settings . padding y ; float max width = settings . max width , max height = settings . max height ; int edge padding x = 0 , edge padding y = 0 ; if ( settings . edge padding ) { if ( settings . duplicate padding ) { max width -= padding x ; max height -= padding y ; } else { max width -= padding x * 2 ; max height -= padding y * 2 ; edge padding x = padding x ; edge padding y = padding y ; } } int min width = integer . max value , min height = integer . max value ; for ( int i = 0 , nn = input rects . size ; i < nn ; i ++ ) { rect rect = input rects . get ( i ) ; min width = math . min ( min width , rect . width ) ; min height = math . min ( min height , rect . height ) ; float width = rect . width - padding x , height = rect . height - padding y ; if ( settings . rotation ) { if ( ( width > max width || height > max height ) && ( width > max height || height > max width ) ) { string padding message = ( edge padding x > 0 || edge padding y > 0 ) ? ( " and edge padding " + padding x + "," + padding y ) : "" ; throw new runtime exception ( "Image does not fit with max page size " + settings . max width + "x" + settings . max height + padding message + ": " + rect . name + "[" + width + "," + height + "]" ) ; } } else { if ( width > max width ) { string padding message = edge padding x > 0 ? ( " and X edge padding " + padding x ) : "" ; throw new runtime exception ( "Image does not fit with max page width " + settings . max width + padding message + ": " + rect . name + "[" + width + "," + height + "]" ) ; } if ( height > max height && ( ! settings . rotation || width > max height ) ) { string padding message = edge padding y > 0 ? ( " and Y edge padding " + padding y ) : "" ; throw new runtime exception ( "Image does not fit in max page height " + settings . max height + padding message + ": " + rect . name + "[" + width + "," + height + "]" ) ; } } } min width = math . max ( min width , settings . min width ) ; min height = math . max ( min height , settings . min height ) ; if ( ! settings . silent ) system . out . print ( "Packing" ) ; page best result = null ; if ( settings . square ) { int min size = math . max ( min width , min height ) ; int max size = math . min ( settings . max width , settings . max height ) ; binary search size search = new binary search ( min size , max size , settings . fast ? 25 : 15 , settings . pot ) ; int size = size search . reset ( ) , i = 0 ; while ( size != - 1 ) { page result = pack at size ( true , size - edge padding x , size - edge padding y , input rects ) ; if ( ! settings . silent ) { if ( ++ i % 70 == 0 ) system . out . println ( ) ; system . out . print ( "." ) ; } best result = get best ( best result , result ) ; size = size search . next ( result == null ) ; } if ( ! settings . silent ) system . out . println ( ) ; if ( best result == null ) best result = pack at size ( false , max size - edge padding x , max size - edge padding y , input rects ) ; sort . sort ( best result . output rects , rect comparator ) ; best result . width = math . max ( best result . width , best result . height ) ; best result . height = math . max ( best result . width , best result . height ) ; return best result ; } else { binary search width search = new binary search ( min width , settings . max width , settings . fast ? 25 : 15 , settings . pot ) ; binary search height search = new binary search ( min height , settings . max height , settings . fast ? 25 : 15 , settings . pot ) ; int width = width search . reset ( ) , i = 0 ; int height = settings . square ? width : height search . reset ( ) ; while ( true ) { page best width result = null ; while ( width != - 1 ) { page result = pack at size ( true , width - edge padding x , height - edge padding y , input rects ) ; if ( ! settings . silent ) { if ( ++ i % 70 == 0 ) system . out . println ( ) ; system . out . print ( "." ) ; } best width result = get best ( best width result , result ) ; width = width search . next ( result == null ) ; if ( settings . square ) height = width ; } best result = get best ( best result , best width result ) ; if ( settings . square ) break ; height = height search . next ( best width result == null ) ; if ( height == - 1 ) break ; width = width search . reset ( ) ; } if ( ! settings . silent ) system . out . println ( ) ; if ( best result == null ) best result = pack at size ( false , settings . max width - edge padding x , settings . max height - edge padding y , input rects ) ; sort . sort ( best result . output rects , rect comparator ) ; return best result ; } } <SENTENCE_END/>

page

<SENTENCE_START> { int padding x = settings . padding x , padding y = settings . padding y ; float max width = settings . max width , max height = settings . max height ; int edge padding x = 0 , edge padding y = 0 ; if ( settings . edge padding ) { if ( settings . duplicate padding ) { max width -= padding x ; max height -= padding y ; } else { max width -= padding x * 2 ; max height -= padding y * 2 ; edge padding x = padding x ; edge padding y = padding y ; } } int min width = integer . max value , min height = integer . max value ; for ( int i = 0 , nn = input rects . size ; i < nn ; i ++ ) { rect rect = input rects . get ( i ) ; min width = math . min ( min width , rect . width ) ; min height = math . min ( min height , rect . height ) ; float width = rect . width - padding x , height = rect . height - padding y ; if ( settings . rotation ) { if ( ( width > max width || height > max height ) && ( width > max height || height > max width ) ) { string padding message = ( edge padding x > 0 || edge padding y > 0 ) ? ( " and edge padding " + padding x + "," + padding y ) : "" ; throw new runtime exception ( "Image does not fit with max page size " + settings . max width + "x" + settings . max height + padding message + ": " + rect . name + "[" + width + "," + height + "]" ) ; } } else { if ( width > max width ) { string padding message = edge padding x > 0 ? ( " and X edge padding " + padding x ) : "" ; throw new runtime exception ( "Image does not fit with max page width " + settings . max width + padding message + ": " + rect . name + "[" + width + "," + height + "]" ) ; } if ( height > max height && ( ! settings . rotation || width > max height ) ) { string padding message = edge padding y > 0 ? ( " and Y edge padding " + padding y ) : "" ; throw new runtime exception ( "Image does not fit in max page height " + settings . max height + padding message + ": " + rect . name + "[" + width + "," + height + "]" ) ; } } } min width = math . max ( min width , settings . min width ) ; min height = math . max ( min height , settings . min height ) ; if ( ! settings . silent ) system . out . print ( "Packing" ) ; page best result = null ; if ( settings . square ) { int min size = math . max ( min width , min height ) ; int max size = math . min ( settings . max width , settings . max height ) ; binary search size search = new binary search ( min size , max size , settings . fast ? 25 : 15 , settings . pot ) ; int size = size search . reset ( ) , i = 0 ; while ( size != - 1 ) { page result = pack at size ( true , size - edge padding x , size - edge padding y , input rects ) ; if ( ! settings . silent ) { if ( ++ i % 70 == 0 ) system . out . println ( ) ; system . out . print ( "." ) ; } best result = get best ( best result , result ) ; size = size search . next ( result == null ) ; } if ( ! settings . silent ) system . out . println ( ) ; if ( best result == null ) best result = pack at size ( false , max size - edge padding x , max size - edge padding y , input rects ) ; sort . sort ( best result . output rects , rect comparator ) ; best result . width = math . max ( best result . width , best result . height ) ; best result . height = math . max ( best result . width , best result . height ) ; return best result ; } else { binary search width search = new binary search ( min width , settings . max width , settings . fast ? 25 : 15 , settings . pot ) ; binary search height search = new binary search ( min height , settings . max height , settings . fast ? 25 : 15 , settings . pot ) ; int width = width search . reset ( ) , i = 0 ; int height = settings . square ? width : height search . reset ( ) ; while ( true ) { page best width result = null ; while ( width != - 1 ) { page result = pack at size ( true , width - edge padding x , height - edge padding y , input rects ) ; if ( ! settings . silent ) { if ( ++ i % 70 == 0 ) system . out . println ( ) ; system . out . print ( "." ) ; } best width result = get best ( best width result , result ) ; width = width search . next ( result == null ) ; if ( settings . square ) height = width ; } best result = get best ( best result , best width result ) ; if ( settings . square ) break ; height = height search . next ( best width result == null ) ; if ( height == - 1 ) break ; width = width search . reset ( ) ; } if ( ! settings . silent ) system . out . println ( ) ; if ( best result == null ) best result = pack at size ( false , settings . max width - edge padding x , settings . max height - edge padding y , input rects ) ; sort . sort ( best result . output rects , rect comparator ) ; return best result ; } } <SENTENCE_END/>

(Copy Probability: 7.1%)

<SENTENCE_START> { int padding x = settings . padding x , padding y = settings . padding y ; float max width = settings . max width , max height = settings . max height ; int edge padding x = 0 , edge padding y = 0 ; if ( settings . edge padding ) { if ( settings . duplicate padding ) { max width -= padding x ; max height -= padding y ; } else { max width -= padding x * 2 ; max height -= padding y * 2 ; edge padding x = padding x ; edge padding y = padding y ; } } int min width = integer . max value , min height = integer . max value ; for ( int i = 0 , nn = input rects . size ; i < nn ; i ++ ) { rect rect = input rects . get ( i ) ; min width = math . min ( min width , rect . width ) ; min height = math . min ( min height , rect . height ) ; float width = rect . width - padding x , height = rect . height - padding y ; if ( settings . rotation ) { if ( ( width > max width || height > max height ) && ( width > max height || height > max width ) ) { string padding message = ( edge padding x > 0 || edge padding y > 0 ) ? ( " and edge padding " + padding x + "," + padding y ) : "" ; throw new runtime exception ( "Image does not fit with max page size " + settings . max width + "x" + settings . max height + padding message + ": " + rect . name + "[" + width + "," + height + "]" ) ; } } else { if ( width > max width ) { string padding message = edge padding x > 0 ? ( " and X edge padding " + padding x ) : "" ; throw new runtime exception ( "Image does not fit with max page width " + settings . max width + padding message + ": " + rect . name + "[" + width + "," + height + "]" ) ; } if ( height > max height && ( ! settings . rotation || width > max height ) ) { string padding message = edge padding y > 0 ? ( " and Y edge padding " + padding y ) : "" ; throw new runtime exception ( "Image does not fit in max page height " + settings . max height + padding message + ": " + rect . name + "[" + width + "," + height + "]" ) ; } } } min width = math . max ( min width , settings . min width ) ; min height = math . max ( min height , settings . min height ) ; if ( ! settings . silent ) system . out . print ( "Packing" ) ; page best result = null ; if ( settings . square ) { int min size = math . max ( min width , min height ) ; int max size = math . min ( settings . max width , settings . max height ) ; binary search size search = new binary search ( min size , max size , settings . fast ? 25 : 15 , settings . pot ) ; int size = size search . reset ( ) , i = 0 ; while ( size != - 1 ) { page result = pack at size ( true , size - edge padding x , size - edge padding y , input rects ) ; if ( ! settings . silent ) { if ( ++ i % 70 == 0 ) system . out . println ( ) ; system . out . print ( "." ) ; } best result = get best ( best result , result ) ; size = size search . next ( result == null ) ; } if ( ! settings . silent ) system . out . println ( ) ; if ( best result == null ) best result = pack at size ( false , max size - edge padding x , max size - edge padding y , input rects ) ; sort . sort ( best result . output rects , rect comparator ) ; best result . width = math . max ( best result . width , best result . height ) ; best result . height = math . max ( best result . width , best result . height ) ; return best result ; } else { binary search width search = new binary search ( min width , settings . max width , settings . fast ? 25 : 15 , settings . pot ) ; binary search height search = new binary search ( min height , settings . max height , settings . fast ? 25 : 15 , settings . pot ) ; int width = width search . reset ( ) , i = 0 ; int height = settings . square ? width : height search . reset ( ) ; while ( true ) { page best width result = null ; while ( width != - 1 ) { page result = pack at size ( true , width - edge padding x , height - edge padding y , input rects ) ; if ( ! settings . silent ) { if ( ++ i % 70 == 0 ) system . out . println ( ) ; system . out . print ( "." ) ; } best width result = get best ( best width result , result ) ; width = width search . next ( result == null ) ; if ( settings . square ) height = width ; } best result = get best ( best result , best width result ) ; if ( settings . square ) break ; height = height search . next ( best width result == null ) ; if ( height == - 1 ) break ; width = width search . reset ( ) ; } if ( ! settings . silent ) system . out . println ( ) ; if ( best result == null ) best result = pack at size ( false , settings . max width - edge padding x , settings . max height - edge padding y , input rects ) ; sort . sort ( best result . output rects , rect comparator ) ; return best result ; } } <SENTENCE_END/>

%END%

<SENTENCE_START> { int padding x = settings . padding x , padding y = settings . padding y ; float max width = settings . max width , max height = settings . max height ; int edge padding x = 0 , edge padding y = 0 ; if ( settings . edge padding ) { if ( settings . duplicate padding ) { max width -= padding x ; max height -= padding y ; } else { max width -= padding x * 2 ; max height -= padding y * 2 ; edge padding x = padding x ; edge padding y = padding y ; } } int min width = integer . max value , min height = integer . max value ; for ( int i = 0 , nn = input rects . size ; i < nn ; i ++ ) { rect rect = input rects . get ( i ) ; min width = math . min ( min width , rect . width ) ; min height = math . min ( min height , rect . height ) ; float width = rect . width - padding x , height = rect . height - padding y ; if ( settings . rotation ) { if ( ( width > max width || height > max height ) && ( width > max height || height > max width ) ) { string padding message = ( edge padding x > 0 || edge padding y > 0 ) ? ( " and edge padding " + padding x + "," + padding y ) : "" ; throw new runtime exception ( "Image does not fit with max page size " + settings . max width + "x" + settings . max height + padding message + ": " + rect . name + "[" + width + "," + height + "]" ) ; } } else { if ( width > max width ) { string padding message = edge padding x > 0 ? ( " and X edge padding " + padding x ) : "" ; throw new runtime exception ( "Image does not fit with max page width " + settings . max width + padding message + ": " + rect . name + "[" + width + "," + height + "]" ) ; } if ( height > max height && ( ! settings . rotation || width > max height ) ) { string padding message = edge padding y > 0 ? ( " and Y edge padding " + padding y ) : "" ; throw new runtime exception ( "Image does not fit in max page height " + settings . max height + padding message + ": " + rect . name + "[" + width + "," + height + "]" ) ; } } } min width = math . max ( min width , settings . min width ) ; min height = math . max ( min height , settings . min height ) ; if ( ! settings . silent ) system . out . print ( "Packing" ) ; page best result = null ; if ( settings . square ) { int min size = math . max ( min width , min height ) ; int max size = math . min ( settings . max width , settings . max height ) ; binary search size search = new binary search ( min size , max size , settings . fast ? 25 : 15 , settings . pot ) ; int size = size search . reset ( ) , i = 0 ; while ( size != - 1 ) { page result = pack at size ( true , size - edge padding x , size - edge padding y , input rects ) ; if ( ! settings . silent ) { if ( ++ i % 70 == 0 ) system . out . println ( ) ; system . out . print ( "." ) ; } best result = get best ( best result , result ) ; size = size search . next ( result == null ) ; } if ( ! settings . silent ) system . out . println ( ) ; if ( best result == null ) best result = pack at size ( false , max size - edge padding x , max size - edge padding y , input rects ) ; sort . sort ( best result . output rects , rect comparator ) ; best result . width = math . max ( best result . width , best result . height ) ; best result . height = math . max ( best result . width , best result . height ) ; return best result ; } else { binary search width search = new binary search ( min width , settings . max width , settings . fast ? 25 : 15 , settings . pot ) ; binary search height search = new binary search ( min height , settings . max height , settings . fast ? 25 : 15 , settings . pot ) ; int width = width search . reset ( ) , i = 0 ; int height = settings . square ? width : height search . reset ( ) ; while ( true ) { page best width result = null ; while ( width != - 1 ) { page result = pack at size ( true , width - edge padding x , height - edge padding y , input rects ) ; if ( ! settings . silent ) { if ( ++ i % 70 == 0 ) system . out . println ( ) ; system . out . print ( "." ) ; } best width result = get best ( best width result , result ) ; width = width search . next ( result == null ) ; if ( settings . square ) height = width ; } best result = get best ( best result , best width result ) ; if ( settings . square ) break ; height = height search . next ( best width result == null ) ; if ( height == - 1 ) break ; width = width search . reset ( ) ; } if ( ! settings . silent ) system . out . println ( ) ; if ( best result == null ) best result = pack at size ( false , settings . max width - edge padding x , settings . max height - edge padding y , input rects ) ; sort . sort ( best result . output rects , rect comparator ) ; return best result ; } } <SENTENCE_END/>

(Copy Probability: 5.2%)

<SENTENCE_START> { int padding x = settings . padding x , padding y = settings . padding y ; float max width = settings . max width , max height = settings . max height ; int edge padding x = 0 , edge padding y = 0 ; if ( settings . edge padding ) { if ( settings . duplicate padding ) { max width -= padding x ; max height -= padding y ; } else { max width -= padding x * 2 ; max height -= padding y * 2 ; edge padding x = padding x ; edge padding y = padding y ; } } int min width = integer . max value , min height = integer . max value ; for ( int i = 0 , nn = input rects . size ; i < nn ; i ++ ) { rect rect = input rects . get ( i ) ; min width = math . min ( min width , rect . width ) ; min height = math . min ( min height , rect . height ) ; float width = rect . width - padding x , height = rect . height - padding y ; if ( settings . rotation ) { if ( ( width > max width || height > max height ) && ( width > max height || height > max width ) ) { string padding message = ( edge padding x > 0 || edge padding y > 0 ) ? ( " and edge padding " + padding x + "," + padding y ) : "" ; throw new runtime exception ( "Image does not fit with max page size " + settings . max width + "x" + settings . max height + padding message + ": " + rect . name + "[" + width + "," + height + "]" ) ; } } else { if ( width > max width ) { string padding message = edge padding x > 0 ? ( " and X edge padding " + padding x ) : "" ; throw new runtime exception ( "Image does not fit with max page width " + settings . max width + padding message + ": " + rect . name + "[" + width + "," + height + "]" ) ; } if ( height > max height && ( ! settings . rotation || width > max height ) ) { string padding message = edge padding y > 0 ? ( " and Y edge padding " + padding y ) : "" ; throw new runtime exception ( "Image does not fit in max page height " + settings . max height + padding message + ": " + rect . name + "[" + width + "," + height + "]" ) ; } } } min width = math . max ( min width , settings . min width ) ; min height = math . max ( min height , settings . min height ) ; if ( ! settings . silent ) system . out . print ( "Packing" ) ; page best result = null ; if ( settings . square ) { int min size = math . max ( min width , min height ) ; int max size = math . min ( settings . max width , settings . max height ) ; binary search size search = new binary search ( min size , max size , settings . fast ? 25 : 15 , settings . pot ) ; int size = size search . reset ( ) , i = 0 ; while ( size != - 1 ) { page result = pack at size ( true , size - edge padding x , size - edge padding y , input rects ) ; if ( ! settings . silent ) { if ( ++ i % 70 == 0 ) system . out . println ( ) ; system . out . print ( "." ) ; } best result = get best ( best result , result ) ; size = size search . next ( result == null ) ; } if ( ! settings . silent ) system . out . println ( ) ; if ( best result == null ) best result = pack at size ( false , max size - edge padding x , max size - edge padding y , input rects ) ; sort . sort ( best result . output rects , rect comparator ) ; best result . width = math . max ( best result . width , best result . height ) ; best result . height = math . max ( best result . width , best result . height ) ; return best result ; } else { binary search width search = new binary search ( min width , settings . max width , settings . fast ? 25 : 15 , settings . pot ) ; binary search height search = new binary search ( min height , settings . max height , settings . fast ? 25 : 15 , settings . pot ) ; int width = width search . reset ( ) , i = 0 ; int height = settings . square ? width : height search . reset ( ) ; while ( true ) { page best width result = null ; while ( width != - 1 ) { page result = pack at size ( true , width - edge padding x , height - edge padding y , input rects ) ; if ( ! settings . silent ) { if ( ++ i % 70 == 0 ) system . out . println ( ) ; system . out . print ( "." ) ; } best width result = get best ( best width result , result ) ; width = width search . next ( result == null ) ; if ( settings . square ) height = width ; } best result = get best ( best result , best width result ) ; if ( settings . square ) break ; height = height search . next ( best width result == null ) ; if ( height == - 1 ) break ; width = width search . reset ( ) ; } if ( ! settings . silent ) system . out . println ( ) ; if ( best result == null ) best result = pack at size ( false , settings . max width - edge padding x , settings . max height - edge padding y , input rects ) ; sort . sort ( best result . output rects , rect comparator ) ; return best result ; } } <SENTENCE_END/>

Original Name pack,at,size

pack

<SENTENCE_START> { page best result = null ; for ( int i = 0 , n = methods . length ; i < n ; i ++ ) { max rects . init ( width , height ) ; page result ; if ( ! settings . fast ) { result = max rects . pack ( input rects , methods [ i ] ) ; } else { array < rect > remaining = new array ( ) ; for ( int ii = 0 , nn = input rects . size ; ii < nn ; ii ++ ) { rect rect = input rects . get ( ii ) ; if ( max rects . insert ( rect , methods [ i ] ) == null ) { while ( ii < nn ) remaining . add ( input rects . get ( ii ++ ) ) ; } } result = max rects . get result ( ) ; result . remaining rects = remaining ; } if ( fully && result . remaining rects . size > 0 ) continue ; if ( result . output rects . size == 0 ) continue ; best result = get best ( best result , result ) ; } return best result ; } <SENTENCE_END/>

(Copy Probability: 3.6%)

<SENTENCE_START> { page best result = null ; for ( int i = 0 , n = methods . length ; i < n ; i ++ ) { max rects . init ( width , height ) ; page result ; if ( ! settings . fast ) { result = max rects . pack ( input rects , methods [ i ] ) ; } else { array < rect > remaining = new array ( ) ; for ( int ii = 0 , nn = input rects . size ; ii < nn ; ii ++ ) { rect rect = input rects . get ( ii ) ; if ( max rects . insert ( rect , methods [ i ] ) == null ) { while ( ii < nn ) remaining . add ( input rects . get ( ii ++ ) ) ; } } result = max rects . get result ( ) ; result . remaining rects = remaining ; } if ( fully && result . remaining rects . size > 0 ) continue ; if ( result . output rects . size == 0 ) continue ; best result = get best ( best result , result ) ; } return best result ; } <SENTENCE_END/>

at

<SENTENCE_START> { page best result = null ; for ( int i = 0 , n = methods . length ; i < n ; i ++ ) { max rects . init ( width , height ) ; page result ; if ( ! settings . fast ) { result = max rects . pack ( input rects , methods [ i ] ) ; } else { array < rect > remaining = new array ( ) ; for ( int ii = 0 , nn = input rects . size ; ii < nn ; ii ++ ) { rect rect = input rects . get ( ii ) ; if ( max rects . insert ( rect , methods [ i ] ) == null ) { while ( ii < nn ) remaining . add ( input rects . get ( ii ++ ) ) ; } } result = max rects . get result ( ) ; result . remaining rects = remaining ; } if ( fully && result . remaining rects . size > 0 ) continue ; if ( result . output rects . size == 0 ) continue ; best result = get best ( best result , result ) ; } return best result ; } <SENTENCE_END/>

(Copy Probability: 8.1%)

<SENTENCE_START> { page best result = null ; for ( int i = 0 , n = methods . length ; i < n ; i ++ ) { max rects . init ( width , height ) ; page result ; if ( ! settings . fast ) { result = max rects . pack ( input rects , methods [ i ] ) ; } else { array < rect > remaining = new array ( ) ; for ( int ii = 0 , nn = input rects . size ; ii < nn ; ii ++ ) { rect rect = input rects . get ( ii ) ; if ( max rects . insert ( rect , methods [ i ] ) == null ) { while ( ii < nn ) remaining . add ( input rects . get ( ii ++ ) ) ; } } result = max rects . get result ( ) ; result . remaining rects = remaining ; } if ( fully && result . remaining rects . size > 0 ) continue ; if ( result . output rects . size == 0 ) continue ; best result = get best ( best result , result ) ; } return best result ; } <SENTENCE_END/>

size

<SENTENCE_START> { page best result = null ; for ( int i = 0 , n = methods . length ; i < n ; i ++ ) { max rects . init ( width , height ) ; page result ; if ( ! settings . fast ) { result = max rects . pack ( input rects , methods [ i ] ) ; } else { array < rect > remaining = new array ( ) ; for ( int ii = 0 , nn = input rects . size ; ii < nn ; ii ++ ) { rect rect = input rects . get ( ii ) ; if ( max rects . insert ( rect , methods [ i ] ) == null ) { while ( ii < nn ) remaining . add ( input rects . get ( ii ++ ) ) ; } } result = max rects . get result ( ) ; result . remaining rects = remaining ; } if ( fully && result . remaining rects . size > 0 ) continue ; if ( result . output rects . size == 0 ) continue ; best result = get best ( best result , result ) ; } return best result ; } <SENTENCE_END/>

(Copy Probability: 10.3%)

<SENTENCE_START> { page best result = null ; for ( int i = 0 , n = methods . length ; i < n ; i ++ ) { max rects . init ( width , height ) ; page result ; if ( ! settings . fast ) { result = max rects . pack ( input rects , methods [ i ] ) ; } else { array < rect > remaining = new array ( ) ; for ( int ii = 0 , nn = input rects . size ; ii < nn ; ii ++ ) { rect rect = input rects . get ( ii ) ; if ( max rects . insert ( rect , methods [ i ] ) == null ) { while ( ii < nn ) remaining . add ( input rects . get ( ii ++ ) ) ; } } result = max rects . get result ( ) ; result . remaining rects = remaining ; } if ( fully && result . remaining rects . size > 0 ) continue ; if ( result . output rects . size == 0 ) continue ; best result = get best ( best result , result ) ; } return best result ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { page best result = null ; for ( int i = 0 , n = methods . length ; i < n ; i ++ ) { max rects . init ( width , height ) ; page result ; if ( ! settings . fast ) { result = max rects . pack ( input rects , methods [ i ] ) ; } else { array < rect > remaining = new array ( ) ; for ( int ii = 0 , nn = input rects . size ; ii < nn ; ii ++ ) { rect rect = input rects . get ( ii ) ; if ( max rects . insert ( rect , methods [ i ] ) == null ) { while ( ii < nn ) remaining . add ( input rects . get ( ii ++ ) ) ; } } result = max rects . get result ( ) ; result . remaining rects = remaining ; } if ( fully && result . remaining rects . size > 0 ) continue ; if ( result . output rects . size == 0 ) continue ; best result = get best ( best result , result ) ; } return best result ; } <SENTENCE_END/>

(Copy Probability: 5.1%)

<SENTENCE_START> { page best result = null ; for ( int i = 0 , n = methods . length ; i < n ; i ++ ) { max rects . init ( width , height ) ; page result ; if ( ! settings . fast ) { result = max rects . pack ( input rects , methods [ i ] ) ; } else { array < rect > remaining = new array ( ) ; for ( int ii = 0 , nn = input rects . size ; ii < nn ; ii ++ ) { rect rect = input rects . get ( ii ) ; if ( max rects . insert ( rect , methods [ i ] ) == null ) { while ( ii < nn ) remaining . add ( input rects . get ( ii ++ ) ) ; } } result = max rects . get result ( ) ; result . remaining rects = remaining ; } if ( fully && result . remaining rects . size > 0 ) continue ; if ( result . output rects . size == 0 ) continue ; best result = get best ( best result , result ) ; } return best result ; } <SENTENCE_END/>

Original Name get,best

get

<SENTENCE_START> { if ( result 1 == null ) return result 2 ; if ( result 2 == null ) return result 1 ; return result 1 . occupancy > result 2 . occupancy ? result 1 : result 2 ; } <SENTENCE_END/>

(Copy Probability: 1.7%)

<SENTENCE_START> { if ( result 1 == null ) return result 2 ; if ( result 2 == null ) return result 1 ; return result 1 . occupancy > result 2 . occupancy ? result 1 : result 2 ; } <SENTENCE_END/>

best

<SENTENCE_START> { if ( result 1 == null ) return result 2 ; if ( result 2 == null ) return result 1 ; return result 1 . occupancy > result 2 . occupancy ? result 1 : result 2 ; } <SENTENCE_END/>

(Copy Probability: 13.3%)

<SENTENCE_START> { if ( result 1 == null ) return result 2 ; if ( result 2 == null ) return result 1 ; return result 1 . occupancy > result 2 . occupancy ? result 1 : result 2 ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { if ( result 1 == null ) return result 2 ; if ( result 2 == null ) return result 1 ; return result 1 . occupancy > result 2 . occupancy ? result 1 : result 2 ; } <SENTENCE_END/>

(Copy Probability: 12.3%)

<SENTENCE_START> { if ( result 1 == null ) return result 2 ; if ( result 2 == null ) return result 1 ; return result 1 . occupancy > result 2 . occupancy ? result 1 : result 2 ; } <SENTENCE_END/>

Original Name reset

reset

<SENTENCE_START> { low = min ; high = max ; current = ( low + high ) >>> 1 ; return pot ? ( int ) math . pow ( 2 , current ) : current ; } <SENTENCE_END/>

(Copy Probability: 2.2%)

<SENTENCE_START> { low = min ; high = max ; current = ( low + high ) >>> 1 ; return pot ? ( int ) math . pow ( 2 , current ) : current ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { low = min ; high = max ; current = ( low + high ) >>> 1 ; return pot ? ( int ) math . pow ( 2 , current ) : current ; } <SENTENCE_END/>

(Copy Probability: 7.4%)

<SENTENCE_START> { low = min ; high = max ; current = ( low + high ) >>> 1 ; return pot ? ( int ) math . pow ( 2 , current ) : current ; } <SENTENCE_END/>

Original Name next

next

<SENTENCE_START> { if ( low >= high ) return - 1 ; if ( result ) low = current + 1 ; else high = current - 1 ; current = ( low + high ) >>> 1 ; if ( math . abs ( low - high ) < fuzziness ) return - 1 ; return pot ? ( int ) math . pow ( 2 , current ) : current ; } <SENTENCE_END/>

(Copy Probability: 2.9%)

<SENTENCE_START> { if ( low >= high ) return - 1 ; if ( result ) low = current + 1 ; else high = current - 1 ; current = ( low + high ) >>> 1 ; if ( math . abs ( low - high ) < fuzziness ) return - 1 ; return pot ? ( int ) math . pow ( 2 , current ) : current ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { if ( low >= high ) return - 1 ; if ( result ) low = current + 1 ; else high = current - 1 ; current = ( low + high ) >>> 1 ; if ( math . abs ( low - high ) < fuzziness ) return - 1 ; return pot ? ( int ) math . pow ( 2 , current ) : current ; } <SENTENCE_END/>

(Copy Probability: 5.4%)

<SENTENCE_START> { if ( low >= high ) return - 1 ; if ( result ) low = current + 1 ; else high = current - 1 ; current = ( low + high ) >>> 1 ; if ( math . abs ( low - high ) < fuzziness ) return - 1 ; return pot ? ( int ) math . pow ( 2 , current ) : current ; } <SENTENCE_END/>

Original Name init

init

<SENTENCE_START> { bin width = width ; bin height = height ; used rectangles . clear ( ) ; free rectangles . clear ( ) ; rect n = new rect ( ) ; n . x = 0 ; n . y = 0 ; n . width = width ; n . height = height ; free rectangles . add ( n ) ; } <SENTENCE_END/>

(Copy Probability: 2.9%)

<SENTENCE_START> { bin width = width ; bin height = height ; used rectangles . clear ( ) ; free rectangles . clear ( ) ; rect n = new rect ( ) ; n . x = 0 ; n . y = 0 ; n . width = width ; n . height = height ; free rectangles . add ( n ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { bin width = width ; bin height = height ; used rectangles . clear ( ) ; free rectangles . clear ( ) ; rect n = new rect ( ) ; n . x = 0 ; n . y = 0 ; n . width = width ; n . height = height ; free rectangles . add ( n ) ; } <SENTENCE_END/>

(Copy Probability: 4.6%)

<SENTENCE_START> { bin width = width ; bin height = height ; used rectangles . clear ( ) ; free rectangles . clear ( ) ; rect n = new rect ( ) ; n . x = 0 ; n . y = 0 ; n . width = width ; n . height = height ; free rectangles . add ( n ) ; } <SENTENCE_END/>

Original Name insert

insert

<SENTENCE_START> { rect new node = score rect ( rect , method ) ; if ( new node . height == 0 ) return null ; int num rectangles to process = free rectangles . size ; for ( int i = 0 ; i < num rectangles to process ; ++ i ) { if ( split free node ( free rectangles . get ( i ) , new node ) ) { free rectangles . remove index ( i ) ; -- i ; -- num rectangles to process ; } } prune free list ( ) ; rect best node = new rect ( ) ; best node . set ( rect ) ; best node . score 1 = new node . score 1 ; best node . score 2 = new node . score 2 ; best node . x = new node . x ; best node . y = new node . y ; best node . width = new node . width ; best node . height = new node . height ; best node . rotated = new node . rotated ; used rectangles . add ( best node ) ; return best node ; } <SENTENCE_END/>

(Copy Probability: 3.1%)

<SENTENCE_START> { rect new node = score rect ( rect , method ) ; if ( new node . height == 0 ) return null ; int num rectangles to process = free rectangles . size ; for ( int i = 0 ; i < num rectangles to process ; ++ i ) { if ( split free node ( free rectangles . get ( i ) , new node ) ) { free rectangles . remove index ( i ) ; -- i ; -- num rectangles to process ; } } prune free list ( ) ; rect best node = new rect ( ) ; best node . set ( rect ) ; best node . score 1 = new node . score 1 ; best node . score 2 = new node . score 2 ; best node . x = new node . x ; best node . y = new node . y ; best node . width = new node . width ; best node . height = new node . height ; best node . rotated = new node . rotated ; used rectangles . add ( best node ) ; return best node ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { rect new node = score rect ( rect , method ) ; if ( new node . height == 0 ) return null ; int num rectangles to process = free rectangles . size ; for ( int i = 0 ; i < num rectangles to process ; ++ i ) { if ( split free node ( free rectangles . get ( i ) , new node ) ) { free rectangles . remove index ( i ) ; -- i ; -- num rectangles to process ; } } prune free list ( ) ; rect best node = new rect ( ) ; best node . set ( rect ) ; best node . score 1 = new node . score 1 ; best node . score 2 = new node . score 2 ; best node . x = new node . x ; best node . y = new node . y ; best node . width = new node . width ; best node . height = new node . height ; best node . rotated = new node . rotated ; used rectangles . add ( best node ) ; return best node ; } <SENTENCE_END/>

(Copy Probability: 17.0%)

<SENTENCE_START> { rect new node = score rect ( rect , method ) ; if ( new node . height == 0 ) return null ; int num rectangles to process = free rectangles . size ; for ( int i = 0 ; i < num rectangles to process ; ++ i ) { if ( split free node ( free rectangles . get ( i ) , new node ) ) { free rectangles . remove index ( i ) ; -- i ; -- num rectangles to process ; } } prune free list ( ) ; rect best node = new rect ( ) ; best node . set ( rect ) ; best node . score 1 = new node . score 1 ; best node . score 2 = new node . score 2 ; best node . x = new node . x ; best node . y = new node . y ; best node . width = new node . width ; best node . height = new node . height ; best node . rotated = new node . rotated ; used rectangles . add ( best node ) ; return best node ; } <SENTENCE_END/>

Original Name pack

pack

<SENTENCE_START> { rects = new array ( rects ) ; while ( rects . size > 0 ) { int best rect index = - 1 ; rect best node = new rect ( ) ; best node . score 1 = integer . max value ; best node . score 2 = integer . max value ; for ( int i = 0 ; i < rects . size ; i ++ ) { rect new node = score rect ( rects . get ( i ) , method ) ; if ( new node . score 1 < best node . score 1 || ( new node . score 1 == best node . score 1 && new node . score 2 < best node . score 2 ) ) { best node . set ( rects . get ( i ) ) ; best node . score 1 = new node . score 1 ; best node . score 2 = new node . score 2 ; best node . x = new node . x ; best node . y = new node . y ; best node . width = new node . width ; best node . height = new node . height ; best node . rotated = new node . rotated ; best rect index = i ; } } if ( best rect index == - 1 ) break ; place rect ( best node ) ; rects . remove index ( best rect index ) ; } page result = get result ( ) ; result . remaining rects = rects ; return result ; } <SENTENCE_END/>

(Copy Probability: 3.3%)

<SENTENCE_START> { rects = new array ( rects ) ; while ( rects . size > 0 ) { int best rect index = - 1 ; rect best node = new rect ( ) ; best node . score 1 = integer . max value ; best node . score 2 = integer . max value ; for ( int i = 0 ; i < rects . size ; i ++ ) { rect new node = score rect ( rects . get ( i ) , method ) ; if ( new node . score 1 < best node . score 1 || ( new node . score 1 == best node . score 1 && new node . score 2 < best node . score 2 ) ) { best node . set ( rects . get ( i ) ) ; best node . score 1 = new node . score 1 ; best node . score 2 = new node . score 2 ; best node . x = new node . x ; best node . y = new node . y ; best node . width = new node . width ; best node . height = new node . height ; best node . rotated = new node . rotated ; best rect index = i ; } } if ( best rect index == - 1 ) break ; place rect ( best node ) ; rects . remove index ( best rect index ) ; } page result = get result ( ) ; result . remaining rects = rects ; return result ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { rects = new array ( rects ) ; while ( rects . size > 0 ) { int best rect index = - 1 ; rect best node = new rect ( ) ; best node . score 1 = integer . max value ; best node . score 2 = integer . max value ; for ( int i = 0 ; i < rects . size ; i ++ ) { rect new node = score rect ( rects . get ( i ) , method ) ; if ( new node . score 1 < best node . score 1 || ( new node . score 1 == best node . score 1 && new node . score 2 < best node . score 2 ) ) { best node . set ( rects . get ( i ) ) ; best node . score 1 = new node . score 1 ; best node . score 2 = new node . score 2 ; best node . x = new node . x ; best node . y = new node . y ; best node . width = new node . width ; best node . height = new node . height ; best node . rotated = new node . rotated ; best rect index = i ; } } if ( best rect index == - 1 ) break ; place rect ( best node ) ; rects . remove index ( best rect index ) ; } page result = get result ( ) ; result . remaining rects = rects ; return result ; } <SENTENCE_END/>

(Copy Probability: 10.5%)

<SENTENCE_START> { rects = new array ( rects ) ; while ( rects . size > 0 ) { int best rect index = - 1 ; rect best node = new rect ( ) ; best node . score 1 = integer . max value ; best node . score 2 = integer . max value ; for ( int i = 0 ; i < rects . size ; i ++ ) { rect new node = score rect ( rects . get ( i ) , method ) ; if ( new node . score 1 < best node . score 1 || ( new node . score 1 == best node . score 1 && new node . score 2 < best node . score 2 ) ) { best node . set ( rects . get ( i ) ) ; best node . score 1 = new node . score 1 ; best node . score 2 = new node . score 2 ; best node . x = new node . x ; best node . y = new node . y ; best node . width = new node . width ; best node . height = new node . height ; best node . rotated = new node . rotated ; best rect index = i ; } } if ( best rect index == - 1 ) break ; place rect ( best node ) ; rects . remove index ( best rect index ) ; } page result = get result ( ) ; result . remaining rects = rects ; return result ; } <SENTENCE_END/>

Original Name get,result

get

<SENTENCE_START> { int w = 0 , h = 0 ; for ( int i = 0 ; i < used rectangles . size ; i ++ ) { rect rect = used rectangles . get ( i ) ; w = math . max ( w , rect . x + rect . width ) ; h = math . max ( h , rect . y + rect . height ) ; } page result = new page ( ) ; result . output rects = new array ( used rectangles ) ; result . occupancy = get occupancy ( ) ; result . width = w ; result . height = h ; return result ; } <SENTENCE_END/>

(Copy Probability: 3.5%)

<SENTENCE_START> { int w = 0 , h = 0 ; for ( int i = 0 ; i < used rectangles . size ; i ++ ) { rect rect = used rectangles . get ( i ) ; w = math . max ( w , rect . x + rect . width ) ; h = math . max ( h , rect . y + rect . height ) ; } page result = new page ( ) ; result . output rects = new array ( used rectangles ) ; result . occupancy = get occupancy ( ) ; result . width = w ; result . height = h ; return result ; } <SENTENCE_END/>

result

<SENTENCE_START> { int w = 0 , h = 0 ; for ( int i = 0 ; i < used rectangles . size ; i ++ ) { rect rect = used rectangles . get ( i ) ; w = math . max ( w , rect . x + rect . width ) ; h = math . max ( h , rect . y + rect . height ) ; } page result = new page ( ) ; result . output rects = new array ( used rectangles ) ; result . occupancy = get occupancy ( ) ; result . width = w ; result . height = h ; return result ; } <SENTENCE_END/>

(Copy Probability: 18.0%)

<SENTENCE_START> { int w = 0 , h = 0 ; for ( int i = 0 ; i < used rectangles . size ; i ++ ) { rect rect = used rectangles . get ( i ) ; w = math . max ( w , rect . x + rect . width ) ; h = math . max ( h , rect . y + rect . height ) ; } page result = new page ( ) ; result . output rects = new array ( used rectangles ) ; result . occupancy = get occupancy ( ) ; result . width = w ; result . height = h ; return result ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { int w = 0 , h = 0 ; for ( int i = 0 ; i < used rectangles . size ; i ++ ) { rect rect = used rectangles . get ( i ) ; w = math . max ( w , rect . x + rect . width ) ; h = math . max ( h , rect . y + rect . height ) ; } page result = new page ( ) ; result . output rects = new array ( used rectangles ) ; result . occupancy = get occupancy ( ) ; result . width = w ; result . height = h ; return result ; } <SENTENCE_END/>

(Copy Probability: 15.3%)

<SENTENCE_START> { int w = 0 , h = 0 ; for ( int i = 0 ; i < used rectangles . size ; i ++ ) { rect rect = used rectangles . get ( i ) ; w = math . max ( w , rect . x + rect . width ) ; h = math . max ( h , rect . y + rect . height ) ; } page result = new page ( ) ; result . output rects = new array ( used rectangles ) ; result . occupancy = get occupancy ( ) ; result . width = w ; result . height = h ; return result ; } <SENTENCE_END/>

Original Name place,rect

place

<SENTENCE_START> { int num rectangles to process = free rectangles . size ; for ( int i = 0 ; i < num rectangles to process ; i ++ ) { if ( split free node ( free rectangles . get ( i ) , node ) ) { free rectangles . remove index ( i ) ; -- i ; -- num rectangles to process ; } } prune free list ( ) ; used rectangles . add ( node ) ; } <SENTENCE_END/>

(Copy Probability: 3.3%)

<SENTENCE_START> { int num rectangles to process = free rectangles . size ; for ( int i = 0 ; i < num rectangles to process ; i ++ ) { if ( split free node ( free rectangles . get ( i ) , node ) ) { free rectangles . remove index ( i ) ; -- i ; -- num rectangles to process ; } } prune free list ( ) ; used rectangles . add ( node ) ; } <SENTENCE_END/>

rect

<SENTENCE_START> { int num rectangles to process = free rectangles . size ; for ( int i = 0 ; i < num rectangles to process ; i ++ ) { if ( split free node ( free rectangles . get ( i ) , node ) ) { free rectangles . remove index ( i ) ; -- i ; -- num rectangles to process ; } } prune free list ( ) ; used rectangles . add ( node ) ; } <SENTENCE_END/>

(Copy Probability: 35.9%)

<SENTENCE_START> { int num rectangles to process = free rectangles . size ; for ( int i = 0 ; i < num rectangles to process ; i ++ ) { if ( split free node ( free rectangles . get ( i ) , node ) ) { free rectangles . remove index ( i ) ; -- i ; -- num rectangles to process ; } } prune free list ( ) ; used rectangles . add ( node ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { int num rectangles to process = free rectangles . size ; for ( int i = 0 ; i < num rectangles to process ; i ++ ) { if ( split free node ( free rectangles . get ( i ) , node ) ) { free rectangles . remove index ( i ) ; -- i ; -- num rectangles to process ; } } prune free list ( ) ; used rectangles . add ( node ) ; } <SENTENCE_END/>

(Copy Probability: 19.1%)

<SENTENCE_START> { int num rectangles to process = free rectangles . size ; for ( int i = 0 ; i < num rectangles to process ; i ++ ) { if ( split free node ( free rectangles . get ( i ) , node ) ) { free rectangles . remove index ( i ) ; -- i ; -- num rectangles to process ; } } prune free list ( ) ; used rectangles . add ( node ) ; } <SENTENCE_END/>

Original Name score,rect

score

<SENTENCE_START> { int width = rect . width ; int height = rect . height ; int rotated width = height - settings . padding y + settings . padding x ; int rotated height = width - settings . padding x + settings . padding y ; boolean rotate = rect . can rotate && settings . rotation ; rect new node = null ; switch ( method ) { case best short side fit : new node = find position for new node best short side fit ( width , height , rotated width , rotated height , rotate ) ; break ; case bottom left rule : new node = find position for new node bottom left ( width , height , rotated width , rotated height , rotate ) ; break ; case contact point rule : new node = find position for new node contact point ( width , height , rotated width , rotated height , rotate ) ; new node . score 1 = - new node . score 1 ; break ; case best long side fit : new node = find position for new node best long side fit ( width , height , rotated width , rotated height , rotate ) ; break ; case best area fit : new node = find position for new node best area fit ( width , height , rotated width , rotated height , rotate ) ; break ; } if ( new node . height == 0 ) { new node . score 1 = integer . max value ; new node . score 2 = integer . max value ; } return new node ; } <SENTENCE_END/>

(Copy Probability: 3.7%)

<SENTENCE_START> { int width = rect . width ; int height = rect . height ; int rotated width = height - settings . padding y + settings . padding x ; int rotated height = width - settings . padding x + settings . padding y ; boolean rotate = rect . can rotate && settings . rotation ; rect new node = null ; switch ( method ) { case best short side fit : new node = find position for new node best short side fit ( width , height , rotated width , rotated height , rotate ) ; break ; case bottom left rule : new node = find position for new node bottom left ( width , height , rotated width , rotated height , rotate ) ; break ; case contact point rule : new node = find position for new node contact point ( width , height , rotated width , rotated height , rotate ) ; new node . score 1 = - new node . score 1 ; break ; case best long side fit : new node = find position for new node best long side fit ( width , height , rotated width , rotated height , rotate ) ; break ; case best area fit : new node = find position for new node best area fit ( width , height , rotated width , rotated height , rotate ) ; break ; } if ( new node . height == 0 ) { new node . score 1 = integer . max value ; new node . score 2 = integer . max value ; } return new node ; } <SENTENCE_END/>

rect

<SENTENCE_START> { int width = rect . width ; int height = rect . height ; int rotated width = height - settings . padding y + settings . padding x ; int rotated height = width - settings . padding x + settings . padding y ; boolean rotate = rect . can rotate && settings . rotation ; rect new node = null ; switch ( method ) { case best short side fit : new node = find position for new node best short side fit ( width , height , rotated width , rotated height , rotate ) ; break ; case bottom left rule : new node = find position for new node bottom left ( width , height , rotated width , rotated height , rotate ) ; break ; case contact point rule : new node = find position for new node contact point ( width , height , rotated width , rotated height , rotate ) ; new node . score 1 = - new node . score 1 ; break ; case best long side fit : new node = find position for new node best long side fit ( width , height , rotated width , rotated height , rotate ) ; break ; case best area fit : new node = find position for new node best area fit ( width , height , rotated width , rotated height , rotate ) ; break ; } if ( new node . height == 0 ) { new node . score 1 = integer . max value ; new node . score 2 = integer . max value ; } return new node ; } <SENTENCE_END/>

(Copy Probability: 12.5%)

<SENTENCE_START> { int width = rect . width ; int height = rect . height ; int rotated width = height - settings . padding y + settings . padding x ; int rotated height = width - settings . padding x + settings . padding y ; boolean rotate = rect . can rotate && settings . rotation ; rect new node = null ; switch ( method ) { case best short side fit : new node = find position for new node best short side fit ( width , height , rotated width , rotated height , rotate ) ; break ; case bottom left rule : new node = find position for new node bottom left ( width , height , rotated width , rotated height , rotate ) ; break ; case contact point rule : new node = find position for new node contact point ( width , height , rotated width , rotated height , rotate ) ; new node . score 1 = - new node . score 1 ; break ; case best long side fit : new node = find position for new node best long side fit ( width , height , rotated width , rotated height , rotate ) ; break ; case best area fit : new node = find position for new node best area fit ( width , height , rotated width , rotated height , rotate ) ; break ; } if ( new node . height == 0 ) { new node . score 1 = integer . max value ; new node . score 2 = integer . max value ; } return new node ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { int width = rect . width ; int height = rect . height ; int rotated width = height - settings . padding y + settings . padding x ; int rotated height = width - settings . padding x + settings . padding y ; boolean rotate = rect . can rotate && settings . rotation ; rect new node = null ; switch ( method ) { case best short side fit : new node = find position for new node best short side fit ( width , height , rotated width , rotated height , rotate ) ; break ; case bottom left rule : new node = find position for new node bottom left ( width , height , rotated width , rotated height , rotate ) ; break ; case contact point rule : new node = find position for new node contact point ( width , height , rotated width , rotated height , rotate ) ; new node . score 1 = - new node . score 1 ; break ; case best long side fit : new node = find position for new node best long side fit ( width , height , rotated width , rotated height , rotate ) ; break ; case best area fit : new node = find position for new node best area fit ( width , height , rotated width , rotated height , rotate ) ; break ; } if ( new node . height == 0 ) { new node . score 1 = integer . max value ; new node . score 2 = integer . max value ; } return new node ; } <SENTENCE_END/>

(Copy Probability: 11.0%)

<SENTENCE_START> { int width = rect . width ; int height = rect . height ; int rotated width = height - settings . padding y + settings . padding x ; int rotated height = width - settings . padding x + settings . padding y ; boolean rotate = rect . can rotate && settings . rotation ; rect new node = null ; switch ( method ) { case best short side fit : new node = find position for new node best short side fit ( width , height , rotated width , rotated height , rotate ) ; break ; case bottom left rule : new node = find position for new node bottom left ( width , height , rotated width , rotated height , rotate ) ; break ; case contact point rule : new node = find position for new node contact point ( width , height , rotated width , rotated height , rotate ) ; new node . score 1 = - new node . score 1 ; break ; case best long side fit : new node = find position for new node best long side fit ( width , height , rotated width , rotated height , rotate ) ; break ; case best area fit : new node = find position for new node best area fit ( width , height , rotated width , rotated height , rotate ) ; break ; } if ( new node . height == 0 ) { new node . score 1 = integer . max value ; new node . score 2 = integer . max value ; } return new node ; } <SENTENCE_END/>

Original Name get,occupancy

get

<SENTENCE_START> { int used surface area = 0 ; for ( int i = 0 ; i < used rectangles . size ; i ++ ) used surface area += used rectangles . get ( i ) . width * used rectangles . get ( i ) . height ; return ( float ) used surface area / ( bin width * bin height ) ; } <SENTENCE_END/>

(Copy Probability: 5.6%)

<SENTENCE_START> { int used surface area = 0 ; for ( int i = 0 ; i < used rectangles . size ; i ++ ) used surface area += used rectangles . get ( i ) . width * used rectangles . get ( i ) . height ; return ( float ) used surface area / ( bin width * bin height ) ; } <SENTENCE_END/>

occupancy

<SENTENCE_START> { int used surface area = 0 ; for ( int i = 0 ; i < used rectangles . size ; i ++ ) used surface area += used rectangles . get ( i ) . width * used rectangles . get ( i ) . height ; return ( float ) used surface area / ( bin width * bin height ) ; } <SENTENCE_END/>

(Copy Probability: 48.6%)

<SENTENCE_START> { int used surface area = 0 ; for ( int i = 0 ; i < used rectangles . size ; i ++ ) used surface area += used rectangles . get ( i ) . width * used rectangles . get ( i ) . height ; return ( float ) used surface area / ( bin width * bin height ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { int used surface area = 0 ; for ( int i = 0 ; i < used rectangles . size ; i ++ ) used surface area += used rectangles . get ( i ) . width * used rectangles . get ( i ) . height ; return ( float ) used surface area / ( bin width * bin height ) ; } <SENTENCE_END/>

(Copy Probability: 44.4%)

<SENTENCE_START> { int used surface area = 0 ; for ( int i = 0 ; i < used rectangles . size ; i ++ ) used surface area += used rectangles . get ( i ) . width * used rectangles . get ( i ) . height ; return ( float ) used surface area / ( bin width * bin height ) ; } <SENTENCE_END/>

Original Name find,position,for,new,node,bottom,left

find

<SENTENCE_START> { rect best node = new rect ( ) ; best node . score 1 = integer . max value ; for ( int i = 0 ; i < free rectangles . size ; i ++ ) { if ( free rectangles . get ( i ) . width >= width && free rectangles . get ( i ) . height >= height ) { int top side y = free rectangles . get ( i ) . y + height ; if ( top side y < best node . score 1 || ( top side y == best node . score 1 && free rectangles . get ( i ) . x < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = width ; best node . height = height ; best node . score 1 = top side y ; best node . score 2 = free rectangles . get ( i ) . x ; best node . rotated = false ; } } if ( rotate && free rectangles . get ( i ) . width >= rotated width && free rectangles . get ( i ) . height >= rotated height ) { int top side y = free rectangles . get ( i ) . y + rotated height ; if ( top side y < best node . score 1 || ( top side y == best node . score 1 && free rectangles . get ( i ) . x < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = rotated width ; best node . height = rotated height ; best node . score 1 = top side y ; best node . score 2 = free rectangles . get ( i ) . x ; best node . rotated = true ; } } } return best node ; } <SENTENCE_END/>

(Copy Probability: 3.1%)

<SENTENCE_START> { rect best node = new rect ( ) ; best node . score 1 = integer . max value ; for ( int i = 0 ; i < free rectangles . size ; i ++ ) { if ( free rectangles . get ( i ) . width >= width && free rectangles . get ( i ) . height >= height ) { int top side y = free rectangles . get ( i ) . y + height ; if ( top side y < best node . score 1 || ( top side y == best node . score 1 && free rectangles . get ( i ) . x < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = width ; best node . height = height ; best node . score 1 = top side y ; best node . score 2 = free rectangles . get ( i ) . x ; best node . rotated = false ; } } if ( rotate && free rectangles . get ( i ) . width >= rotated width && free rectangles . get ( i ) . height >= rotated height ) { int top side y = free rectangles . get ( i ) . y + rotated height ; if ( top side y < best node . score 1 || ( top side y == best node . score 1 && free rectangles . get ( i ) . x < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = rotated width ; best node . height = rotated height ; best node . score 1 = top side y ; best node . score 2 = free rectangles . get ( i ) . x ; best node . rotated = true ; } } } return best node ; } <SENTENCE_END/>

position

<SENTENCE_START> { rect best node = new rect ( ) ; best node . score 1 = integer . max value ; for ( int i = 0 ; i < free rectangles . size ; i ++ ) { if ( free rectangles . get ( i ) . width >= width && free rectangles . get ( i ) . height >= height ) { int top side y = free rectangles . get ( i ) . y + height ; if ( top side y < best node . score 1 || ( top side y == best node . score 1 && free rectangles . get ( i ) . x < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = width ; best node . height = height ; best node . score 1 = top side y ; best node . score 2 = free rectangles . get ( i ) . x ; best node . rotated = false ; } } if ( rotate && free rectangles . get ( i ) . width >= rotated width && free rectangles . get ( i ) . height >= rotated height ) { int top side y = free rectangles . get ( i ) . y + rotated height ; if ( top side y < best node . score 1 || ( top side y == best node . score 1 && free rectangles . get ( i ) . x < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = rotated width ; best node . height = rotated height ; best node . score 1 = top side y ; best node . score 2 = free rectangles . get ( i ) . x ; best node . rotated = true ; } } } return best node ; } <SENTENCE_END/>

(Copy Probability: 9.3%)

<SENTENCE_START> { rect best node = new rect ( ) ; best node . score 1 = integer . max value ; for ( int i = 0 ; i < free rectangles . size ; i ++ ) { if ( free rectangles . get ( i ) . width >= width && free rectangles . get ( i ) . height >= height ) { int top side y = free rectangles . get ( i ) . y + height ; if ( top side y < best node . score 1 || ( top side y == best node . score 1 && free rectangles . get ( i ) . x < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = width ; best node . height = height ; best node . score 1 = top side y ; best node . score 2 = free rectangles . get ( i ) . x ; best node . rotated = false ; } } if ( rotate && free rectangles . get ( i ) . width >= rotated width && free rectangles . get ( i ) . height >= rotated height ) { int top side y = free rectangles . get ( i ) . y + rotated height ; if ( top side y < best node . score 1 || ( top side y == best node . score 1 && free rectangles . get ( i ) . x < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = rotated width ; best node . height = rotated height ; best node . score 1 = top side y ; best node . score 2 = free rectangles . get ( i ) . x ; best node . rotated = true ; } } } return best node ; } <SENTENCE_END/>

for

<SENTENCE_START> { rect best node = new rect ( ) ; best node . score 1 = integer . max value ; for ( int i = 0 ; i < free rectangles . size ; i ++ ) { if ( free rectangles . get ( i ) . width >= width && free rectangles . get ( i ) . height >= height ) { int top side y = free rectangles . get ( i ) . y + height ; if ( top side y < best node . score 1 || ( top side y == best node . score 1 && free rectangles . get ( i ) . x < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = width ; best node . height = height ; best node . score 1 = top side y ; best node . score 2 = free rectangles . get ( i ) . x ; best node . rotated = false ; } } if ( rotate && free rectangles . get ( i ) . width >= rotated width && free rectangles . get ( i ) . height >= rotated height ) { int top side y = free rectangles . get ( i ) . y + rotated height ; if ( top side y < best node . score 1 || ( top side y == best node . score 1 && free rectangles . get ( i ) . x < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = rotated width ; best node . height = rotated height ; best node . score 1 = top side y ; best node . score 2 = free rectangles . get ( i ) . x ; best node . rotated = true ; } } } return best node ; } <SENTENCE_END/>

(Copy Probability: 4.4%)

<SENTENCE_START> { rect best node = new rect ( ) ; best node . score 1 = integer . max value ; for ( int i = 0 ; i < free rectangles . size ; i ++ ) { if ( free rectangles . get ( i ) . width >= width && free rectangles . get ( i ) . height >= height ) { int top side y = free rectangles . get ( i ) . y + height ; if ( top side y < best node . score 1 || ( top side y == best node . score 1 && free rectangles . get ( i ) . x < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = width ; best node . height = height ; best node . score 1 = top side y ; best node . score 2 = free rectangles . get ( i ) . x ; best node . rotated = false ; } } if ( rotate && free rectangles . get ( i ) . width >= rotated width && free rectangles . get ( i ) . height >= rotated height ) { int top side y = free rectangles . get ( i ) . y + rotated height ; if ( top side y < best node . score 1 || ( top side y == best node . score 1 && free rectangles . get ( i ) . x < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = rotated width ; best node . height = rotated height ; best node . score 1 = top side y ; best node . score 2 = free rectangles . get ( i ) . x ; best node . rotated = true ; } } } return best node ; } <SENTENCE_END/>

new

<SENTENCE_START> { rect best node = new rect ( ) ; best node . score 1 = integer . max value ; for ( int i = 0 ; i < free rectangles . size ; i ++ ) { if ( free rectangles . get ( i ) . width >= width && free rectangles . get ( i ) . height >= height ) { int top side y = free rectangles . get ( i ) . y + height ; if ( top side y < best node . score 1 || ( top side y == best node . score 1 && free rectangles . get ( i ) . x < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = width ; best node . height = height ; best node . score 1 = top side y ; best node . score 2 = free rectangles . get ( i ) . x ; best node . rotated = false ; } } if ( rotate && free rectangles . get ( i ) . width >= rotated width && free rectangles . get ( i ) . height >= rotated height ) { int top side y = free rectangles . get ( i ) . y + rotated height ; if ( top side y < best node . score 1 || ( top side y == best node . score 1 && free rectangles . get ( i ) . x < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = rotated width ; best node . height = rotated height ; best node . score 1 = top side y ; best node . score 2 = free rectangles . get ( i ) . x ; best node . rotated = true ; } } } return best node ; } <SENTENCE_END/>

(Copy Probability: 3.3%)

<SENTENCE_START> { rect best node = new rect ( ) ; best node . score 1 = integer . max value ; for ( int i = 0 ; i < free rectangles . size ; i ++ ) { if ( free rectangles . get ( i ) . width >= width && free rectangles . get ( i ) . height >= height ) { int top side y = free rectangles . get ( i ) . y + height ; if ( top side y < best node . score 1 || ( top side y == best node . score 1 && free rectangles . get ( i ) . x < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = width ; best node . height = height ; best node . score 1 = top side y ; best node . score 2 = free rectangles . get ( i ) . x ; best node . rotated = false ; } } if ( rotate && free rectangles . get ( i ) . width >= rotated width && free rectangles . get ( i ) . height >= rotated height ) { int top side y = free rectangles . get ( i ) . y + rotated height ; if ( top side y < best node . score 1 || ( top side y == best node . score 1 && free rectangles . get ( i ) . x < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = rotated width ; best node . height = rotated height ; best node . score 1 = top side y ; best node . score 2 = free rectangles . get ( i ) . x ; best node . rotated = true ; } } } return best node ; } <SENTENCE_END/>

node

<SENTENCE_START> { rect best node = new rect ( ) ; best node . score 1 = integer . max value ; for ( int i = 0 ; i < free rectangles . size ; i ++ ) { if ( free rectangles . get ( i ) . width >= width && free rectangles . get ( i ) . height >= height ) { int top side y = free rectangles . get ( i ) . y + height ; if ( top side y < best node . score 1 || ( top side y == best node . score 1 && free rectangles . get ( i ) . x < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = width ; best node . height = height ; best node . score 1 = top side y ; best node . score 2 = free rectangles . get ( i ) . x ; best node . rotated = false ; } } if ( rotate && free rectangles . get ( i ) . width >= rotated width && free rectangles . get ( i ) . height >= rotated height ) { int top side y = free rectangles . get ( i ) . y + rotated height ; if ( top side y < best node . score 1 || ( top side y == best node . score 1 && free rectangles . get ( i ) . x < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = rotated width ; best node . height = rotated height ; best node . score 1 = top side y ; best node . score 2 = free rectangles . get ( i ) . x ; best node . rotated = true ; } } } return best node ; } <SENTENCE_END/>

(Copy Probability: 3.8%)

<SENTENCE_START> { rect best node = new rect ( ) ; best node . score 1 = integer . max value ; for ( int i = 0 ; i < free rectangles . size ; i ++ ) { if ( free rectangles . get ( i ) . width >= width && free rectangles . get ( i ) . height >= height ) { int top side y = free rectangles . get ( i ) . y + height ; if ( top side y < best node . score 1 || ( top side y == best node . score 1 && free rectangles . get ( i ) . x < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = width ; best node . height = height ; best node . score 1 = top side y ; best node . score 2 = free rectangles . get ( i ) . x ; best node . rotated = false ; } } if ( rotate && free rectangles . get ( i ) . width >= rotated width && free rectangles . get ( i ) . height >= rotated height ) { int top side y = free rectangles . get ( i ) . y + rotated height ; if ( top side y < best node . score 1 || ( top side y == best node . score 1 && free rectangles . get ( i ) . x < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = rotated width ; best node . height = rotated height ; best node . score 1 = top side y ; best node . score 2 = free rectangles . get ( i ) . x ; best node . rotated = true ; } } } return best node ; } <SENTENCE_END/>

bottom

<SENTENCE_START> { rect best node = new rect ( ) ; best node . score 1 = integer . max value ; for ( int i = 0 ; i < free rectangles . size ; i ++ ) { if ( free rectangles . get ( i ) . width >= width && free rectangles . get ( i ) . height >= height ) { int top side y = free rectangles . get ( i ) . y + height ; if ( top side y < best node . score 1 || ( top side y == best node . score 1 && free rectangles . get ( i ) . x < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = width ; best node . height = height ; best node . score 1 = top side y ; best node . score 2 = free rectangles . get ( i ) . x ; best node . rotated = false ; } } if ( rotate && free rectangles . get ( i ) . width >= rotated width && free rectangles . get ( i ) . height >= rotated height ) { int top side y = free rectangles . get ( i ) . y + rotated height ; if ( top side y < best node . score 1 || ( top side y == best node . score 1 && free rectangles . get ( i ) . x < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = rotated width ; best node . height = rotated height ; best node . score 1 = top side y ; best node . score 2 = free rectangles . get ( i ) . x ; best node . rotated = true ; } } } return best node ; } <SENTENCE_END/>

(Copy Probability: 3.4%)

<SENTENCE_START> { rect best node = new rect ( ) ; best node . score 1 = integer . max value ; for ( int i = 0 ; i < free rectangles . size ; i ++ ) { if ( free rectangles . get ( i ) . width >= width && free rectangles . get ( i ) . height >= height ) { int top side y = free rectangles . get ( i ) . y + height ; if ( top side y < best node . score 1 || ( top side y == best node . score 1 && free rectangles . get ( i ) . x < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = width ; best node . height = height ; best node . score 1 = top side y ; best node . score 2 = free rectangles . get ( i ) . x ; best node . rotated = false ; } } if ( rotate && free rectangles . get ( i ) . width >= rotated width && free rectangles . get ( i ) . height >= rotated height ) { int top side y = free rectangles . get ( i ) . y + rotated height ; if ( top side y < best node . score 1 || ( top side y == best node . score 1 && free rectangles . get ( i ) . x < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = rotated width ; best node . height = rotated height ; best node . score 1 = top side y ; best node . score 2 = free rectangles . get ( i ) . x ; best node . rotated = true ; } } } return best node ; } <SENTENCE_END/>

left

<SENTENCE_START> { rect best node = new rect ( ) ; best node . score 1 = integer . max value ; for ( int i = 0 ; i < free rectangles . size ; i ++ ) { if ( free rectangles . get ( i ) . width >= width && free rectangles . get ( i ) . height >= height ) { int top side y = free rectangles . get ( i ) . y + height ; if ( top side y < best node . score 1 || ( top side y == best node . score 1 && free rectangles . get ( i ) . x < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = width ; best node . height = height ; best node . score 1 = top side y ; best node . score 2 = free rectangles . get ( i ) . x ; best node . rotated = false ; } } if ( rotate && free rectangles . get ( i ) . width >= rotated width && free rectangles . get ( i ) . height >= rotated height ) { int top side y = free rectangles . get ( i ) . y + rotated height ; if ( top side y < best node . score 1 || ( top side y == best node . score 1 && free rectangles . get ( i ) . x < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = rotated width ; best node . height = rotated height ; best node . score 1 = top side y ; best node . score 2 = free rectangles . get ( i ) . x ; best node . rotated = true ; } } } return best node ; } <SENTENCE_END/>

(Copy Probability: 3.9%)

<SENTENCE_START> { rect best node = new rect ( ) ; best node . score 1 = integer . max value ; for ( int i = 0 ; i < free rectangles . size ; i ++ ) { if ( free rectangles . get ( i ) . width >= width && free rectangles . get ( i ) . height >= height ) { int top side y = free rectangles . get ( i ) . y + height ; if ( top side y < best node . score 1 || ( top side y == best node . score 1 && free rectangles . get ( i ) . x < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = width ; best node . height = height ; best node . score 1 = top side y ; best node . score 2 = free rectangles . get ( i ) . x ; best node . rotated = false ; } } if ( rotate && free rectangles . get ( i ) . width >= rotated width && free rectangles . get ( i ) . height >= rotated height ) { int top side y = free rectangles . get ( i ) . y + rotated height ; if ( top side y < best node . score 1 || ( top side y == best node . score 1 && free rectangles . get ( i ) . x < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = rotated width ; best node . height = rotated height ; best node . score 1 = top side y ; best node . score 2 = free rectangles . get ( i ) . x ; best node . rotated = true ; } } } return best node ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { rect best node = new rect ( ) ; best node . score 1 = integer . max value ; for ( int i = 0 ; i < free rectangles . size ; i ++ ) { if ( free rectangles . get ( i ) . width >= width && free rectangles . get ( i ) . height >= height ) { int top side y = free rectangles . get ( i ) . y + height ; if ( top side y < best node . score 1 || ( top side y == best node . score 1 && free rectangles . get ( i ) . x < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = width ; best node . height = height ; best node . score 1 = top side y ; best node . score 2 = free rectangles . get ( i ) . x ; best node . rotated = false ; } } if ( rotate && free rectangles . get ( i ) . width >= rotated width && free rectangles . get ( i ) . height >= rotated height ) { int top side y = free rectangles . get ( i ) . y + rotated height ; if ( top side y < best node . score 1 || ( top side y == best node . score 1 && free rectangles . get ( i ) . x < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = rotated width ; best node . height = rotated height ; best node . score 1 = top side y ; best node . score 2 = free rectangles . get ( i ) . x ; best node . rotated = true ; } } } return best node ; } <SENTENCE_END/>

(Copy Probability: 3.9%)

<SENTENCE_START> { rect best node = new rect ( ) ; best node . score 1 = integer . max value ; for ( int i = 0 ; i < free rectangles . size ; i ++ ) { if ( free rectangles . get ( i ) . width >= width && free rectangles . get ( i ) . height >= height ) { int top side y = free rectangles . get ( i ) . y + height ; if ( top side y < best node . score 1 || ( top side y == best node . score 1 && free rectangles . get ( i ) . x < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = width ; best node . height = height ; best node . score 1 = top side y ; best node . score 2 = free rectangles . get ( i ) . x ; best node . rotated = false ; } } if ( rotate && free rectangles . get ( i ) . width >= rotated width && free rectangles . get ( i ) . height >= rotated height ) { int top side y = free rectangles . get ( i ) . y + rotated height ; if ( top side y < best node . score 1 || ( top side y == best node . score 1 && free rectangles . get ( i ) . x < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = rotated width ; best node . height = rotated height ; best node . score 1 = top side y ; best node . score 2 = free rectangles . get ( i ) . x ; best node . rotated = true ; } } } return best node ; } <SENTENCE_END/>

Original Name find,position,for,new,node,best,short,side,fit

find

<SENTENCE_START> { rect best node = new rect ( ) ; best node . score 1 = integer . max value ; for ( int i = 0 ; i < free rectangles . size ; i ++ ) { if ( free rectangles . get ( i ) . width >= width && free rectangles . get ( i ) . height >= height ) { int leftover horiz = math . abs ( free rectangles . get ( i ) . width - width ) ; int leftover vert = math . abs ( free rectangles . get ( i ) . height - height ) ; int short side fit = math . min ( leftover horiz , leftover vert ) ; int long side fit = math . max ( leftover horiz , leftover vert ) ; if ( short side fit < best node . score 1 || ( short side fit == best node . score 1 && long side fit < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = width ; best node . height = height ; best node . score 1 = short side fit ; best node . score 2 = long side fit ; best node . rotated = false ; } } if ( rotate && free rectangles . get ( i ) . width >= rotated width && free rectangles . get ( i ) . height >= rotated height ) { int flipped leftover horiz = math . abs ( free rectangles . get ( i ) . width - rotated width ) ; int flipped leftover vert = math . abs ( free rectangles . get ( i ) . height - rotated height ) ; int flipped short side fit = math . min ( flipped leftover horiz , flipped leftover vert ) ; int flipped long side fit = math . max ( flipped leftover horiz , flipped leftover vert ) ; if ( flipped short side fit < best node . score 1 || ( flipped short side fit == best node . score 1 && flipped long side fit < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = rotated width ; best node . height = rotated height ; best node . score 1 = flipped short side fit ; best node . score 2 = flipped long side fit ; best node . rotated = true ; } } } return best node ; } <SENTENCE_END/>

(Copy Probability: 3.7%)

<SENTENCE_START> { rect best node = new rect ( ) ; best node . score 1 = integer . max value ; for ( int i = 0 ; i < free rectangles . size ; i ++ ) { if ( free rectangles . get ( i ) . width >= width && free rectangles . get ( i ) . height >= height ) { int leftover horiz = math . abs ( free rectangles . get ( i ) . width - width ) ; int leftover vert = math . abs ( free rectangles . get ( i ) . height - height ) ; int short side fit = math . min ( leftover horiz , leftover vert ) ; int long side fit = math . max ( leftover horiz , leftover vert ) ; if ( short side fit < best node . score 1 || ( short side fit == best node . score 1 && long side fit < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = width ; best node . height = height ; best node . score 1 = short side fit ; best node . score 2 = long side fit ; best node . rotated = false ; } } if ( rotate && free rectangles . get ( i ) . width >= rotated width && free rectangles . get ( i ) . height >= rotated height ) { int flipped leftover horiz = math . abs ( free rectangles . get ( i ) . width - rotated width ) ; int flipped leftover vert = math . abs ( free rectangles . get ( i ) . height - rotated height ) ; int flipped short side fit = math . min ( flipped leftover horiz , flipped leftover vert ) ; int flipped long side fit = math . max ( flipped leftover horiz , flipped leftover vert ) ; if ( flipped short side fit < best node . score 1 || ( flipped short side fit == best node . score 1 && flipped long side fit < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = rotated width ; best node . height = rotated height ; best node . score 1 = flipped short side fit ; best node . score 2 = flipped long side fit ; best node . rotated = true ; } } } return best node ; } <SENTENCE_END/>

position

<SENTENCE_START> { rect best node = new rect ( ) ; best node . score 1 = integer . max value ; for ( int i = 0 ; i < free rectangles . size ; i ++ ) { if ( free rectangles . get ( i ) . width >= width && free rectangles . get ( i ) . height >= height ) { int leftover horiz = math . abs ( free rectangles . get ( i ) . width - width ) ; int leftover vert = math . abs ( free rectangles . get ( i ) . height - height ) ; int short side fit = math . min ( leftover horiz , leftover vert ) ; int long side fit = math . max ( leftover horiz , leftover vert ) ; if ( short side fit < best node . score 1 || ( short side fit == best node . score 1 && long side fit < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = width ; best node . height = height ; best node . score 1 = short side fit ; best node . score 2 = long side fit ; best node . rotated = false ; } } if ( rotate && free rectangles . get ( i ) . width >= rotated width && free rectangles . get ( i ) . height >= rotated height ) { int flipped leftover horiz = math . abs ( free rectangles . get ( i ) . width - rotated width ) ; int flipped leftover vert = math . abs ( free rectangles . get ( i ) . height - rotated height ) ; int flipped short side fit = math . min ( flipped leftover horiz , flipped leftover vert ) ; int flipped long side fit = math . max ( flipped leftover horiz , flipped leftover vert ) ; if ( flipped short side fit < best node . score 1 || ( flipped short side fit == best node . score 1 && flipped long side fit < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = rotated width ; best node . height = rotated height ; best node . score 1 = flipped short side fit ; best node . score 2 = flipped long side fit ; best node . rotated = true ; } } } return best node ; } <SENTENCE_END/>

(Copy Probability: 9.4%)

<SENTENCE_START> { rect best node = new rect ( ) ; best node . score 1 = integer . max value ; for ( int i = 0 ; i < free rectangles . size ; i ++ ) { if ( free rectangles . get ( i ) . width >= width && free rectangles . get ( i ) . height >= height ) { int leftover horiz = math . abs ( free rectangles . get ( i ) . width - width ) ; int leftover vert = math . abs ( free rectangles . get ( i ) . height - height ) ; int short side fit = math . min ( leftover horiz , leftover vert ) ; int long side fit = math . max ( leftover horiz , leftover vert ) ; if ( short side fit < best node . score 1 || ( short side fit == best node . score 1 && long side fit < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = width ; best node . height = height ; best node . score 1 = short side fit ; best node . score 2 = long side fit ; best node . rotated = false ; } } if ( rotate && free rectangles . get ( i ) . width >= rotated width && free rectangles . get ( i ) . height >= rotated height ) { int flipped leftover horiz = math . abs ( free rectangles . get ( i ) . width - rotated width ) ; int flipped leftover vert = math . abs ( free rectangles . get ( i ) . height - rotated height ) ; int flipped short side fit = math . min ( flipped leftover horiz , flipped leftover vert ) ; int flipped long side fit = math . max ( flipped leftover horiz , flipped leftover vert ) ; if ( flipped short side fit < best node . score 1 || ( flipped short side fit == best node . score 1 && flipped long side fit < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = rotated width ; best node . height = rotated height ; best node . score 1 = flipped short side fit ; best node . score 2 = flipped long side fit ; best node . rotated = true ; } } } return best node ; } <SENTENCE_END/>

for

<SENTENCE_START> { rect best node = new rect ( ) ; best node . score 1 = integer . max value ; for ( int i = 0 ; i < free rectangles . size ; i ++ ) { if ( free rectangles . get ( i ) . width >= width && free rectangles . get ( i ) . height >= height ) { int leftover horiz = math . abs ( free rectangles . get ( i ) . width - width ) ; int leftover vert = math . abs ( free rectangles . get ( i ) . height - height ) ; int short side fit = math . min ( leftover horiz , leftover vert ) ; int long side fit = math . max ( leftover horiz , leftover vert ) ; if ( short side fit < best node . score 1 || ( short side fit == best node . score 1 && long side fit < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = width ; best node . height = height ; best node . score 1 = short side fit ; best node . score 2 = long side fit ; best node . rotated = false ; } } if ( rotate && free rectangles . get ( i ) . width >= rotated width && free rectangles . get ( i ) . height >= rotated height ) { int flipped leftover horiz = math . abs ( free rectangles . get ( i ) . width - rotated width ) ; int flipped leftover vert = math . abs ( free rectangles . get ( i ) . height - rotated height ) ; int flipped short side fit = math . min ( flipped leftover horiz , flipped leftover vert ) ; int flipped long side fit = math . max ( flipped leftover horiz , flipped leftover vert ) ; if ( flipped short side fit < best node . score 1 || ( flipped short side fit == best node . score 1 && flipped long side fit < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = rotated width ; best node . height = rotated height ; best node . score 1 = flipped short side fit ; best node . score 2 = flipped long side fit ; best node . rotated = true ; } } } return best node ; } <SENTENCE_END/>

(Copy Probability: 4.3%)

<SENTENCE_START> { rect best node = new rect ( ) ; best node . score 1 = integer . max value ; for ( int i = 0 ; i < free rectangles . size ; i ++ ) { if ( free rectangles . get ( i ) . width >= width && free rectangles . get ( i ) . height >= height ) { int leftover horiz = math . abs ( free rectangles . get ( i ) . width - width ) ; int leftover vert = math . abs ( free rectangles . get ( i ) . height - height ) ; int short side fit = math . min ( leftover horiz , leftover vert ) ; int long side fit = math . max ( leftover horiz , leftover vert ) ; if ( short side fit < best node . score 1 || ( short side fit == best node . score 1 && long side fit < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = width ; best node . height = height ; best node . score 1 = short side fit ; best node . score 2 = long side fit ; best node . rotated = false ; } } if ( rotate && free rectangles . get ( i ) . width >= rotated width && free rectangles . get ( i ) . height >= rotated height ) { int flipped leftover horiz = math . abs ( free rectangles . get ( i ) . width - rotated width ) ; int flipped leftover vert = math . abs ( free rectangles . get ( i ) . height - rotated height ) ; int flipped short side fit = math . min ( flipped leftover horiz , flipped leftover vert ) ; int flipped long side fit = math . max ( flipped leftover horiz , flipped leftover vert ) ; if ( flipped short side fit < best node . score 1 || ( flipped short side fit == best node . score 1 && flipped long side fit < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = rotated width ; best node . height = rotated height ; best node . score 1 = flipped short side fit ; best node . score 2 = flipped long side fit ; best node . rotated = true ; } } } return best node ; } <SENTENCE_END/>

new

<SENTENCE_START> { rect best node = new rect ( ) ; best node . score 1 = integer . max value ; for ( int i = 0 ; i < free rectangles . size ; i ++ ) { if ( free rectangles . get ( i ) . width >= width && free rectangles . get ( i ) . height >= height ) { int leftover horiz = math . abs ( free rectangles . get ( i ) . width - width ) ; int leftover vert = math . abs ( free rectangles . get ( i ) . height - height ) ; int short side fit = math . min ( leftover horiz , leftover vert ) ; int long side fit = math . max ( leftover horiz , leftover vert ) ; if ( short side fit < best node . score 1 || ( short side fit == best node . score 1 && long side fit < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = width ; best node . height = height ; best node . score 1 = short side fit ; best node . score 2 = long side fit ; best node . rotated = false ; } } if ( rotate && free rectangles . get ( i ) . width >= rotated width && free rectangles . get ( i ) . height >= rotated height ) { int flipped leftover horiz = math . abs ( free rectangles . get ( i ) . width - rotated width ) ; int flipped leftover vert = math . abs ( free rectangles . get ( i ) . height - rotated height ) ; int flipped short side fit = math . min ( flipped leftover horiz , flipped leftover vert ) ; int flipped long side fit = math . max ( flipped leftover horiz , flipped leftover vert ) ; if ( flipped short side fit < best node . score 1 || ( flipped short side fit == best node . score 1 && flipped long side fit < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = rotated width ; best node . height = rotated height ; best node . score 1 = flipped short side fit ; best node . score 2 = flipped long side fit ; best node . rotated = true ; } } } return best node ; } <SENTENCE_END/>

(Copy Probability: 3.3%)

<SENTENCE_START> { rect best node = new rect ( ) ; best node . score 1 = integer . max value ; for ( int i = 0 ; i < free rectangles . size ; i ++ ) { if ( free rectangles . get ( i ) . width >= width && free rectangles . get ( i ) . height >= height ) { int leftover horiz = math . abs ( free rectangles . get ( i ) . width - width ) ; int leftover vert = math . abs ( free rectangles . get ( i ) . height - height ) ; int short side fit = math . min ( leftover horiz , leftover vert ) ; int long side fit = math . max ( leftover horiz , leftover vert ) ; if ( short side fit < best node . score 1 || ( short side fit == best node . score 1 && long side fit < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = width ; best node . height = height ; best node . score 1 = short side fit ; best node . score 2 = long side fit ; best node . rotated = false ; } } if ( rotate && free rectangles . get ( i ) . width >= rotated width && free rectangles . get ( i ) . height >= rotated height ) { int flipped leftover horiz = math . abs ( free rectangles . get ( i ) . width - rotated width ) ; int flipped leftover vert = math . abs ( free rectangles . get ( i ) . height - rotated height ) ; int flipped short side fit = math . min ( flipped leftover horiz , flipped leftover vert ) ; int flipped long side fit = math . max ( flipped leftover horiz , flipped leftover vert ) ; if ( flipped short side fit < best node . score 1 || ( flipped short side fit == best node . score 1 && flipped long side fit < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = rotated width ; best node . height = rotated height ; best node . score 1 = flipped short side fit ; best node . score 2 = flipped long side fit ; best node . rotated = true ; } } } return best node ; } <SENTENCE_END/>

node

<SENTENCE_START> { rect best node = new rect ( ) ; best node . score 1 = integer . max value ; for ( int i = 0 ; i < free rectangles . size ; i ++ ) { if ( free rectangles . get ( i ) . width >= width && free rectangles . get ( i ) . height >= height ) { int leftover horiz = math . abs ( free rectangles . get ( i ) . width - width ) ; int leftover vert = math . abs ( free rectangles . get ( i ) . height - height ) ; int short side fit = math . min ( leftover horiz , leftover vert ) ; int long side fit = math . max ( leftover horiz , leftover vert ) ; if ( short side fit < best node . score 1 || ( short side fit == best node . score 1 && long side fit < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = width ; best node . height = height ; best node . score 1 = short side fit ; best node . score 2 = long side fit ; best node . rotated = false ; } } if ( rotate && free rectangles . get ( i ) . width >= rotated width && free rectangles . get ( i ) . height >= rotated height ) { int flipped leftover horiz = math . abs ( free rectangles . get ( i ) . width - rotated width ) ; int flipped leftover vert = math . abs ( free rectangles . get ( i ) . height - rotated height ) ; int flipped short side fit = math . min ( flipped leftover horiz , flipped leftover vert ) ; int flipped long side fit = math . max ( flipped leftover horiz , flipped leftover vert ) ; if ( flipped short side fit < best node . score 1 || ( flipped short side fit == best node . score 1 && flipped long side fit < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = rotated width ; best node . height = rotated height ; best node . score 1 = flipped short side fit ; best node . score 2 = flipped long side fit ; best node . rotated = true ; } } } return best node ; } <SENTENCE_END/>

(Copy Probability: 3.7%)

<SENTENCE_START> { rect best node = new rect ( ) ; best node . score 1 = integer . max value ; for ( int i = 0 ; i < free rectangles . size ; i ++ ) { if ( free rectangles . get ( i ) . width >= width && free rectangles . get ( i ) . height >= height ) { int leftover horiz = math . abs ( free rectangles . get ( i ) . width - width ) ; int leftover vert = math . abs ( free rectangles . get ( i ) . height - height ) ; int short side fit = math . min ( leftover horiz , leftover vert ) ; int long side fit = math . max ( leftover horiz , leftover vert ) ; if ( short side fit < best node . score 1 || ( short side fit == best node . score 1 && long side fit < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = width ; best node . height = height ; best node . score 1 = short side fit ; best node . score 2 = long side fit ; best node . rotated = false ; } } if ( rotate && free rectangles . get ( i ) . width >= rotated width && free rectangles . get ( i ) . height >= rotated height ) { int flipped leftover horiz = math . abs ( free rectangles . get ( i ) . width - rotated width ) ; int flipped leftover vert = math . abs ( free rectangles . get ( i ) . height - rotated height ) ; int flipped short side fit = math . min ( flipped leftover horiz , flipped leftover vert ) ; int flipped long side fit = math . max ( flipped leftover horiz , flipped leftover vert ) ; if ( flipped short side fit < best node . score 1 || ( flipped short side fit == best node . score 1 && flipped long side fit < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = rotated width ; best node . height = rotated height ; best node . score 1 = flipped short side fit ; best node . score 2 = flipped long side fit ; best node . rotated = true ; } } } return best node ; } <SENTENCE_END/>

best

<SENTENCE_START> { rect best node = new rect ( ) ; best node . score 1 = integer . max value ; for ( int i = 0 ; i < free rectangles . size ; i ++ ) { if ( free rectangles . get ( i ) . width >= width && free rectangles . get ( i ) . height >= height ) { int leftover horiz = math . abs ( free rectangles . get ( i ) . width - width ) ; int leftover vert = math . abs ( free rectangles . get ( i ) . height - height ) ; int short side fit = math . min ( leftover horiz , leftover vert ) ; int long side fit = math . max ( leftover horiz , leftover vert ) ; if ( short side fit < best node . score 1 || ( short side fit == best node . score 1 && long side fit < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = width ; best node . height = height ; best node . score 1 = short side fit ; best node . score 2 = long side fit ; best node . rotated = false ; } } if ( rotate && free rectangles . get ( i ) . width >= rotated width && free rectangles . get ( i ) . height >= rotated height ) { int flipped leftover horiz = math . abs ( free rectangles . get ( i ) . width - rotated width ) ; int flipped leftover vert = math . abs ( free rectangles . get ( i ) . height - rotated height ) ; int flipped short side fit = math . min ( flipped leftover horiz , flipped leftover vert ) ; int flipped long side fit = math . max ( flipped leftover horiz , flipped leftover vert ) ; if ( flipped short side fit < best node . score 1 || ( flipped short side fit == best node . score 1 && flipped long side fit < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = rotated width ; best node . height = rotated height ; best node . score 1 = flipped short side fit ; best node . score 2 = flipped long side fit ; best node . rotated = true ; } } } return best node ; } <SENTENCE_END/>

(Copy Probability: 3.3%)

<SENTENCE_START> { rect best node = new rect ( ) ; best node . score 1 = integer . max value ; for ( int i = 0 ; i < free rectangles . size ; i ++ ) { if ( free rectangles . get ( i ) . width >= width && free rectangles . get ( i ) . height >= height ) { int leftover horiz = math . abs ( free rectangles . get ( i ) . width - width ) ; int leftover vert = math . abs ( free rectangles . get ( i ) . height - height ) ; int short side fit = math . min ( leftover horiz , leftover vert ) ; int long side fit = math . max ( leftover horiz , leftover vert ) ; if ( short side fit < best node . score 1 || ( short side fit == best node . score 1 && long side fit < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = width ; best node . height = height ; best node . score 1 = short side fit ; best node . score 2 = long side fit ; best node . rotated = false ; } } if ( rotate && free rectangles . get ( i ) . width >= rotated width && free rectangles . get ( i ) . height >= rotated height ) { int flipped leftover horiz = math . abs ( free rectangles . get ( i ) . width - rotated width ) ; int flipped leftover vert = math . abs ( free rectangles . get ( i ) . height - rotated height ) ; int flipped short side fit = math . min ( flipped leftover horiz , flipped leftover vert ) ; int flipped long side fit = math . max ( flipped leftover horiz , flipped leftover vert ) ; if ( flipped short side fit < best node . score 1 || ( flipped short side fit == best node . score 1 && flipped long side fit < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = rotated width ; best node . height = rotated height ; best node . score 1 = flipped short side fit ; best node . score 2 = flipped long side fit ; best node . rotated = true ; } } } return best node ; } <SENTENCE_END/>

short

<SENTENCE_START> { rect best node = new rect ( ) ; best node . score 1 = integer . max value ; for ( int i = 0 ; i < free rectangles . size ; i ++ ) { if ( free rectangles . get ( i ) . width >= width && free rectangles . get ( i ) . height >= height ) { int leftover horiz = math . abs ( free rectangles . get ( i ) . width - width ) ; int leftover vert = math . abs ( free rectangles . get ( i ) . height - height ) ; int short side fit = math . min ( leftover horiz , leftover vert ) ; int long side fit = math . max ( leftover horiz , leftover vert ) ; if ( short side fit < best node . score 1 || ( short side fit == best node . score 1 && long side fit < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = width ; best node . height = height ; best node . score 1 = short side fit ; best node . score 2 = long side fit ; best node . rotated = false ; } } if ( rotate && free rectangles . get ( i ) . width >= rotated width && free rectangles . get ( i ) . height >= rotated height ) { int flipped leftover horiz = math . abs ( free rectangles . get ( i ) . width - rotated width ) ; int flipped leftover vert = math . abs ( free rectangles . get ( i ) . height - rotated height ) ; int flipped short side fit = math . min ( flipped leftover horiz , flipped leftover vert ) ; int flipped long side fit = math . max ( flipped leftover horiz , flipped leftover vert ) ; if ( flipped short side fit < best node . score 1 || ( flipped short side fit == best node . score 1 && flipped long side fit < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = rotated width ; best node . height = rotated height ; best node . score 1 = flipped short side fit ; best node . score 2 = flipped long side fit ; best node . rotated = true ; } } } return best node ; } <SENTENCE_END/>

(Copy Probability: 3.7%)

<SENTENCE_START> { rect best node = new rect ( ) ; best node . score 1 = integer . max value ; for ( int i = 0 ; i < free rectangles . size ; i ++ ) { if ( free rectangles . get ( i ) . width >= width && free rectangles . get ( i ) . height >= height ) { int leftover horiz = math . abs ( free rectangles . get ( i ) . width - width ) ; int leftover vert = math . abs ( free rectangles . get ( i ) . height - height ) ; int short side fit = math . min ( leftover horiz , leftover vert ) ; int long side fit = math . max ( leftover horiz , leftover vert ) ; if ( short side fit < best node . score 1 || ( short side fit == best node . score 1 && long side fit < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = width ; best node . height = height ; best node . score 1 = short side fit ; best node . score 2 = long side fit ; best node . rotated = false ; } } if ( rotate && free rectangles . get ( i ) . width >= rotated width && free rectangles . get ( i ) . height >= rotated height ) { int flipped leftover horiz = math . abs ( free rectangles . get ( i ) . width - rotated width ) ; int flipped leftover vert = math . abs ( free rectangles . get ( i ) . height - rotated height ) ; int flipped short side fit = math . min ( flipped leftover horiz , flipped leftover vert ) ; int flipped long side fit = math . max ( flipped leftover horiz , flipped leftover vert ) ; if ( flipped short side fit < best node . score 1 || ( flipped short side fit == best node . score 1 && flipped long side fit < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = rotated width ; best node . height = rotated height ; best node . score 1 = flipped short side fit ; best node . score 2 = flipped long side fit ; best node . rotated = true ; } } } return best node ; } <SENTENCE_END/>

side

<SENTENCE_START> { rect best node = new rect ( ) ; best node . score 1 = integer . max value ; for ( int i = 0 ; i < free rectangles . size ; i ++ ) { if ( free rectangles . get ( i ) . width >= width && free rectangles . get ( i ) . height >= height ) { int leftover horiz = math . abs ( free rectangles . get ( i ) . width - width ) ; int leftover vert = math . abs ( free rectangles . get ( i ) . height - height ) ; int short side fit = math . min ( leftover horiz , leftover vert ) ; int long side fit = math . max ( leftover horiz , leftover vert ) ; if ( short side fit < best node . score 1 || ( short side fit == best node . score 1 && long side fit < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = width ; best node . height = height ; best node . score 1 = short side fit ; best node . score 2 = long side fit ; best node . rotated = false ; } } if ( rotate && free rectangles . get ( i ) . width >= rotated width && free rectangles . get ( i ) . height >= rotated height ) { int flipped leftover horiz = math . abs ( free rectangles . get ( i ) . width - rotated width ) ; int flipped leftover vert = math . abs ( free rectangles . get ( i ) . height - rotated height ) ; int flipped short side fit = math . min ( flipped leftover horiz , flipped leftover vert ) ; int flipped long side fit = math . max ( flipped leftover horiz , flipped leftover vert ) ; if ( flipped short side fit < best node . score 1 || ( flipped short side fit == best node . score 1 && flipped long side fit < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = rotated width ; best node . height = rotated height ; best node . score 1 = flipped short side fit ; best node . score 2 = flipped long side fit ; best node . rotated = true ; } } } return best node ; } <SENTENCE_END/>

(Copy Probability: 3.7%)

<SENTENCE_START> { rect best node = new rect ( ) ; best node . score 1 = integer . max value ; for ( int i = 0 ; i < free rectangles . size ; i ++ ) { if ( free rectangles . get ( i ) . width >= width && free rectangles . get ( i ) . height >= height ) { int leftover horiz = math . abs ( free rectangles . get ( i ) . width - width ) ; int leftover vert = math . abs ( free rectangles . get ( i ) . height - height ) ; int short side fit = math . min ( leftover horiz , leftover vert ) ; int long side fit = math . max ( leftover horiz , leftover vert ) ; if ( short side fit < best node . score 1 || ( short side fit == best node . score 1 && long side fit < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = width ; best node . height = height ; best node . score 1 = short side fit ; best node . score 2 = long side fit ; best node . rotated = false ; } } if ( rotate && free rectangles . get ( i ) . width >= rotated width && free rectangles . get ( i ) . height >= rotated height ) { int flipped leftover horiz = math . abs ( free rectangles . get ( i ) . width - rotated width ) ; int flipped leftover vert = math . abs ( free rectangles . get ( i ) . height - rotated height ) ; int flipped short side fit = math . min ( flipped leftover horiz , flipped leftover vert ) ; int flipped long side fit = math . max ( flipped leftover horiz , flipped leftover vert ) ; if ( flipped short side fit < best node . score 1 || ( flipped short side fit == best node . score 1 && flipped long side fit < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = rotated width ; best node . height = rotated height ; best node . score 1 = flipped short side fit ; best node . score 2 = flipped long side fit ; best node . rotated = true ; } } } return best node ; } <SENTENCE_END/>

fit

<SENTENCE_START> { rect best node = new rect ( ) ; best node . score 1 = integer . max value ; for ( int i = 0 ; i < free rectangles . size ; i ++ ) { if ( free rectangles . get ( i ) . width >= width && free rectangles . get ( i ) . height >= height ) { int leftover horiz = math . abs ( free rectangles . get ( i ) . width - width ) ; int leftover vert = math . abs ( free rectangles . get ( i ) . height - height ) ; int short side fit = math . min ( leftover horiz , leftover vert ) ; int long side fit = math . max ( leftover horiz , leftover vert ) ; if ( short side fit < best node . score 1 || ( short side fit == best node . score 1 && long side fit < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = width ; best node . height = height ; best node . score 1 = short side fit ; best node . score 2 = long side fit ; best node . rotated = false ; } } if ( rotate && free rectangles . get ( i ) . width >= rotated width && free rectangles . get ( i ) . height >= rotated height ) { int flipped leftover horiz = math . abs ( free rectangles . get ( i ) . width - rotated width ) ; int flipped leftover vert = math . abs ( free rectangles . get ( i ) . height - rotated height ) ; int flipped short side fit = math . min ( flipped leftover horiz , flipped leftover vert ) ; int flipped long side fit = math . max ( flipped leftover horiz , flipped leftover vert ) ; if ( flipped short side fit < best node . score 1 || ( flipped short side fit == best node . score 1 && flipped long side fit < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = rotated width ; best node . height = rotated height ; best node . score 1 = flipped short side fit ; best node . score 2 = flipped long side fit ; best node . rotated = true ; } } } return best node ; } <SENTENCE_END/>

(Copy Probability: 3.6%)

<SENTENCE_START> { rect best node = new rect ( ) ; best node . score 1 = integer . max value ; for ( int i = 0 ; i < free rectangles . size ; i ++ ) { if ( free rectangles . get ( i ) . width >= width && free rectangles . get ( i ) . height >= height ) { int leftover horiz = math . abs ( free rectangles . get ( i ) . width - width ) ; int leftover vert = math . abs ( free rectangles . get ( i ) . height - height ) ; int short side fit = math . min ( leftover horiz , leftover vert ) ; int long side fit = math . max ( leftover horiz , leftover vert ) ; if ( short side fit < best node . score 1 || ( short side fit == best node . score 1 && long side fit < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = width ; best node . height = height ; best node . score 1 = short side fit ; best node . score 2 = long side fit ; best node . rotated = false ; } } if ( rotate && free rectangles . get ( i ) . width >= rotated width && free rectangles . get ( i ) . height >= rotated height ) { int flipped leftover horiz = math . abs ( free rectangles . get ( i ) . width - rotated width ) ; int flipped leftover vert = math . abs ( free rectangles . get ( i ) . height - rotated height ) ; int flipped short side fit = math . min ( flipped leftover horiz , flipped leftover vert ) ; int flipped long side fit = math . max ( flipped leftover horiz , flipped leftover vert ) ; if ( flipped short side fit < best node . score 1 || ( flipped short side fit == best node . score 1 && flipped long side fit < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = rotated width ; best node . height = rotated height ; best node . score 1 = flipped short side fit ; best node . score 2 = flipped long side fit ; best node . rotated = true ; } } } return best node ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { rect best node = new rect ( ) ; best node . score 1 = integer . max value ; for ( int i = 0 ; i < free rectangles . size ; i ++ ) { if ( free rectangles . get ( i ) . width >= width && free rectangles . get ( i ) . height >= height ) { int leftover horiz = math . abs ( free rectangles . get ( i ) . width - width ) ; int leftover vert = math . abs ( free rectangles . get ( i ) . height - height ) ; int short side fit = math . min ( leftover horiz , leftover vert ) ; int long side fit = math . max ( leftover horiz , leftover vert ) ; if ( short side fit < best node . score 1 || ( short side fit == best node . score 1 && long side fit < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = width ; best node . height = height ; best node . score 1 = short side fit ; best node . score 2 = long side fit ; best node . rotated = false ; } } if ( rotate && free rectangles . get ( i ) . width >= rotated width && free rectangles . get ( i ) . height >= rotated height ) { int flipped leftover horiz = math . abs ( free rectangles . get ( i ) . width - rotated width ) ; int flipped leftover vert = math . abs ( free rectangles . get ( i ) . height - rotated height ) ; int flipped short side fit = math . min ( flipped leftover horiz , flipped leftover vert ) ; int flipped long side fit = math . max ( flipped leftover horiz , flipped leftover vert ) ; if ( flipped short side fit < best node . score 1 || ( flipped short side fit == best node . score 1 && flipped long side fit < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = rotated width ; best node . height = rotated height ; best node . score 1 = flipped short side fit ; best node . score 2 = flipped long side fit ; best node . rotated = true ; } } } return best node ; } <SENTENCE_END/>

(Copy Probability: 3.7%)

<SENTENCE_START> { rect best node = new rect ( ) ; best node . score 1 = integer . max value ; for ( int i = 0 ; i < free rectangles . size ; i ++ ) { if ( free rectangles . get ( i ) . width >= width && free rectangles . get ( i ) . height >= height ) { int leftover horiz = math . abs ( free rectangles . get ( i ) . width - width ) ; int leftover vert = math . abs ( free rectangles . get ( i ) . height - height ) ; int short side fit = math . min ( leftover horiz , leftover vert ) ; int long side fit = math . max ( leftover horiz , leftover vert ) ; if ( short side fit < best node . score 1 || ( short side fit == best node . score 1 && long side fit < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = width ; best node . height = height ; best node . score 1 = short side fit ; best node . score 2 = long side fit ; best node . rotated = false ; } } if ( rotate && free rectangles . get ( i ) . width >= rotated width && free rectangles . get ( i ) . height >= rotated height ) { int flipped leftover horiz = math . abs ( free rectangles . get ( i ) . width - rotated width ) ; int flipped leftover vert = math . abs ( free rectangles . get ( i ) . height - rotated height ) ; int flipped short side fit = math . min ( flipped leftover horiz , flipped leftover vert ) ; int flipped long side fit = math . max ( flipped leftover horiz , flipped leftover vert ) ; if ( flipped short side fit < best node . score 1 || ( flipped short side fit == best node . score 1 && flipped long side fit < best node . score 2 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = rotated width ; best node . height = rotated height ; best node . score 1 = flipped short side fit ; best node . score 2 = flipped long side fit ; best node . rotated = true ; } } } return best node ; } <SENTENCE_END/>

Original Name find,position,for,new,node,best,long,side,fit

find

<SENTENCE_START> { rect best node = new rect ( ) ; best node . score 2 = integer . max value ; for ( int i = 0 ; i < free rectangles . size ; i ++ ) { if ( free rectangles . get ( i ) . width >= width && free rectangles . get ( i ) . height >= height ) { int leftover horiz = math . abs ( free rectangles . get ( i ) . width - width ) ; int leftover vert = math . abs ( free rectangles . get ( i ) . height - height ) ; int short side fit = math . min ( leftover horiz , leftover vert ) ; int long side fit = math . max ( leftover horiz , leftover vert ) ; if ( long side fit < best node . score 2 || ( long side fit == best node . score 2 && short side fit < best node . score 1 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = width ; best node . height = height ; best node . score 1 = short side fit ; best node . score 2 = long side fit ; best node . rotated = false ; } } if ( rotate && free rectangles . get ( i ) . width >= rotated width && free rectangles . get ( i ) . height >= rotated height ) { int leftover horiz = math . abs ( free rectangles . get ( i ) . width - rotated width ) ; int leftover vert = math . abs ( free rectangles . get ( i ) . height - rotated height ) ; int short side fit = math . min ( leftover horiz , leftover vert ) ; int long side fit = math . max ( leftover horiz , leftover vert ) ; if ( long side fit < best node . score 2 || ( long side fit == best node . score 2 && short side fit < best node . score 1 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = rotated width ; best node . height = rotated height ; best node . score 1 = short side fit ; best node . score 2 = long side fit ; best node . rotated = true ; } } } return best node ; } <SENTENCE_END/>

(Copy Probability: 3.4%)

<SENTENCE_START> { rect best node = new rect ( ) ; best node . score 2 = integer . max value ; for ( int i = 0 ; i < free rectangles . size ; i ++ ) { if ( free rectangles . get ( i ) . width >= width && free rectangles . get ( i ) . height >= height ) { int leftover horiz = math . abs ( free rectangles . get ( i ) . width - width ) ; int leftover vert = math . abs ( free rectangles . get ( i ) . height - height ) ; int short side fit = math . min ( leftover horiz , leftover vert ) ; int long side fit = math . max ( leftover horiz , leftover vert ) ; if ( long side fit < best node . score 2 || ( long side fit == best node . score 2 && short side fit < best node . score 1 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = width ; best node . height = height ; best node . score 1 = short side fit ; best node . score 2 = long side fit ; best node . rotated = false ; } } if ( rotate && free rectangles . get ( i ) . width >= rotated width && free rectangles . get ( i ) . height >= rotated height ) { int leftover horiz = math . abs ( free rectangles . get ( i ) . width - rotated width ) ; int leftover vert = math . abs ( free rectangles . get ( i ) . height - rotated height ) ; int short side fit = math . min ( leftover horiz , leftover vert ) ; int long side fit = math . max ( leftover horiz , leftover vert ) ; if ( long side fit < best node . score 2 || ( long side fit == best node . score 2 && short side fit < best node . score 1 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = rotated width ; best node . height = rotated height ; best node . score 1 = short side fit ; best node . score 2 = long side fit ; best node . rotated = true ; } } } return best node ; } <SENTENCE_END/>

position

<SENTENCE_START> { rect best node = new rect ( ) ; best node . score 2 = integer . max value ; for ( int i = 0 ; i < free rectangles . size ; i ++ ) { if ( free rectangles . get ( i ) . width >= width && free rectangles . get ( i ) . height >= height ) { int leftover horiz = math . abs ( free rectangles . get ( i ) . width - width ) ; int leftover vert = math . abs ( free rectangles . get ( i ) . height - height ) ; int short side fit = math . min ( leftover horiz , leftover vert ) ; int long side fit = math . max ( leftover horiz , leftover vert ) ; if ( long side fit < best node . score 2 || ( long side fit == best node . score 2 && short side fit < best node . score 1 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = width ; best node . height = height ; best node . score 1 = short side fit ; best node . score 2 = long side fit ; best node . rotated = false ; } } if ( rotate && free rectangles . get ( i ) . width >= rotated width && free rectangles . get ( i ) . height >= rotated height ) { int leftover horiz = math . abs ( free rectangles . get ( i ) . width - rotated width ) ; int leftover vert = math . abs ( free rectangles . get ( i ) . height - rotated height ) ; int short side fit = math . min ( leftover horiz , leftover vert ) ; int long side fit = math . max ( leftover horiz , leftover vert ) ; if ( long side fit < best node . score 2 || ( long side fit == best node . score 2 && short side fit < best node . score 1 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = rotated width ; best node . height = rotated height ; best node . score 1 = short side fit ; best node . score 2 = long side fit ; best node . rotated = true ; } } } return best node ; } <SENTENCE_END/>

(Copy Probability: 9.0%)

<SENTENCE_START> { rect best node = new rect ( ) ; best node . score 2 = integer . max value ; for ( int i = 0 ; i < free rectangles . size ; i ++ ) { if ( free rectangles . get ( i ) . width >= width && free rectangles . get ( i ) . height >= height ) { int leftover horiz = math . abs ( free rectangles . get ( i ) . width - width ) ; int leftover vert = math . abs ( free rectangles . get ( i ) . height - height ) ; int short side fit = math . min ( leftover horiz , leftover vert ) ; int long side fit = math . max ( leftover horiz , leftover vert ) ; if ( long side fit < best node . score 2 || ( long side fit == best node . score 2 && short side fit < best node . score 1 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = width ; best node . height = height ; best node . score 1 = short side fit ; best node . score 2 = long side fit ; best node . rotated = false ; } } if ( rotate && free rectangles . get ( i ) . width >= rotated width && free rectangles . get ( i ) . height >= rotated height ) { int leftover horiz = math . abs ( free rectangles . get ( i ) . width - rotated width ) ; int leftover vert = math . abs ( free rectangles . get ( i ) . height - rotated height ) ; int short side fit = math . min ( leftover horiz , leftover vert ) ; int long side fit = math . max ( leftover horiz , leftover vert ) ; if ( long side fit < best node . score 2 || ( long side fit == best node . score 2 && short side fit < best node . score 1 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = rotated width ; best node . height = rotated height ; best node . score 1 = short side fit ; best node . score 2 = long side fit ; best node . rotated = true ; } } } return best node ; } <SENTENCE_END/>

for

<SENTENCE_START> { rect best node = new rect ( ) ; best node . score 2 = integer . max value ; for ( int i = 0 ; i < free rectangles . size ; i ++ ) { if ( free rectangles . get ( i ) . width >= width && free rectangles . get ( i ) . height >= height ) { int leftover horiz = math . abs ( free rectangles . get ( i ) . width - width ) ; int leftover vert = math . abs ( free rectangles . get ( i ) . height - height ) ; int short side fit = math . min ( leftover horiz , leftover vert ) ; int long side fit = math . max ( leftover horiz , leftover vert ) ; if ( long side fit < best node . score 2 || ( long side fit == best node . score 2 && short side fit < best node . score 1 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = width ; best node . height = height ; best node . score 1 = short side fit ; best node . score 2 = long side fit ; best node . rotated = false ; } } if ( rotate && free rectangles . get ( i ) . width >= rotated width && free rectangles . get ( i ) . height >= rotated height ) { int leftover horiz = math . abs ( free rectangles . get ( i ) . width - rotated width ) ; int leftover vert = math . abs ( free rectangles . get ( i ) . height - rotated height ) ; int short side fit = math . min ( leftover horiz , leftover vert ) ; int long side fit = math . max ( leftover horiz , leftover vert ) ; if ( long side fit < best node . score 2 || ( long side fit == best node . score 2 && short side fit < best node . score 1 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = rotated width ; best node . height = rotated height ; best node . score 1 = short side fit ; best node . score 2 = long side fit ; best node . rotated = true ; } } } return best node ; } <SENTENCE_END/>

(Copy Probability: 4.2%)

<SENTENCE_START> { rect best node = new rect ( ) ; best node . score 2 = integer . max value ; for ( int i = 0 ; i < free rectangles . size ; i ++ ) { if ( free rectangles . get ( i ) . width >= width && free rectangles . get ( i ) . height >= height ) { int leftover horiz = math . abs ( free rectangles . get ( i ) . width - width ) ; int leftover vert = math . abs ( free rectangles . get ( i ) . height - height ) ; int short side fit = math . min ( leftover horiz , leftover vert ) ; int long side fit = math . max ( leftover horiz , leftover vert ) ; if ( long side fit < best node . score 2 || ( long side fit == best node . score 2 && short side fit < best node . score 1 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = width ; best node . height = height ; best node . score 1 = short side fit ; best node . score 2 = long side fit ; best node . rotated = false ; } } if ( rotate && free rectangles . get ( i ) . width >= rotated width && free rectangles . get ( i ) . height >= rotated height ) { int leftover horiz = math . abs ( free rectangles . get ( i ) . width - rotated width ) ; int leftover vert = math . abs ( free rectangles . get ( i ) . height - rotated height ) ; int short side fit = math . min ( leftover horiz , leftover vert ) ; int long side fit = math . max ( leftover horiz , leftover vert ) ; if ( long side fit < best node . score 2 || ( long side fit == best node . score 2 && short side fit < best node . score 1 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = rotated width ; best node . height = rotated height ; best node . score 1 = short side fit ; best node . score 2 = long side fit ; best node . rotated = true ; } } } return best node ; } <SENTENCE_END/>

new

<SENTENCE_START> { rect best node = new rect ( ) ; best node . score 2 = integer . max value ; for ( int i = 0 ; i < free rectangles . size ; i ++ ) { if ( free rectangles . get ( i ) . width >= width && free rectangles . get ( i ) . height >= height ) { int leftover horiz = math . abs ( free rectangles . get ( i ) . width - width ) ; int leftover vert = math . abs ( free rectangles . get ( i ) . height - height ) ; int short side fit = math . min ( leftover horiz , leftover vert ) ; int long side fit = math . max ( leftover horiz , leftover vert ) ; if ( long side fit < best node . score 2 || ( long side fit == best node . score 2 && short side fit < best node . score 1 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = width ; best node . height = height ; best node . score 1 = short side fit ; best node . score 2 = long side fit ; best node . rotated = false ; } } if ( rotate && free rectangles . get ( i ) . width >= rotated width && free rectangles . get ( i ) . height >= rotated height ) { int leftover horiz = math . abs ( free rectangles . get ( i ) . width - rotated width ) ; int leftover vert = math . abs ( free rectangles . get ( i ) . height - rotated height ) ; int short side fit = math . min ( leftover horiz , leftover vert ) ; int long side fit = math . max ( leftover horiz , leftover vert ) ; if ( long side fit < best node . score 2 || ( long side fit == best node . score 2 && short side fit < best node . score 1 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = rotated width ; best node . height = rotated height ; best node . score 1 = short side fit ; best node . score 2 = long side fit ; best node . rotated = true ; } } } return best node ; } <SENTENCE_END/>

(Copy Probability: 3.0%)

<SENTENCE_START> { rect best node = new rect ( ) ; best node . score 2 = integer . max value ; for ( int i = 0 ; i < free rectangles . size ; i ++ ) { if ( free rectangles . get ( i ) . width >= width && free rectangles . get ( i ) . height >= height ) { int leftover horiz = math . abs ( free rectangles . get ( i ) . width - width ) ; int leftover vert = math . abs ( free rectangles . get ( i ) . height - height ) ; int short side fit = math . min ( leftover horiz , leftover vert ) ; int long side fit = math . max ( leftover horiz , leftover vert ) ; if ( long side fit < best node . score 2 || ( long side fit == best node . score 2 && short side fit < best node . score 1 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = width ; best node . height = height ; best node . score 1 = short side fit ; best node . score 2 = long side fit ; best node . rotated = false ; } } if ( rotate && free rectangles . get ( i ) . width >= rotated width && free rectangles . get ( i ) . height >= rotated height ) { int leftover horiz = math . abs ( free rectangles . get ( i ) . width - rotated width ) ; int leftover vert = math . abs ( free rectangles . get ( i ) . height - rotated height ) ; int short side fit = math . min ( leftover horiz , leftover vert ) ; int long side fit = math . max ( leftover horiz , leftover vert ) ; if ( long side fit < best node . score 2 || ( long side fit == best node . score 2 && short side fit < best node . score 1 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = rotated width ; best node . height = rotated height ; best node . score 1 = short side fit ; best node . score 2 = long side fit ; best node . rotated = true ; } } } return best node ; } <SENTENCE_END/>

node

<SENTENCE_START> { rect best node = new rect ( ) ; best node . score 2 = integer . max value ; for ( int i = 0 ; i < free rectangles . size ; i ++ ) { if ( free rectangles . get ( i ) . width >= width && free rectangles . get ( i ) . height >= height ) { int leftover horiz = math . abs ( free rectangles . get ( i ) . width - width ) ; int leftover vert = math . abs ( free rectangles . get ( i ) . height - height ) ; int short side fit = math . min ( leftover horiz , leftover vert ) ; int long side fit = math . max ( leftover horiz , leftover vert ) ; if ( long side fit < best node . score 2 || ( long side fit == best node . score 2 && short side fit < best node . score 1 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = width ; best node . height = height ; best node . score 1 = short side fit ; best node . score 2 = long side fit ; best node . rotated = false ; } } if ( rotate && free rectangles . get ( i ) . width >= rotated width && free rectangles . get ( i ) . height >= rotated height ) { int leftover horiz = math . abs ( free rectangles . get ( i ) . width - rotated width ) ; int leftover vert = math . abs ( free rectangles . get ( i ) . height - rotated height ) ; int short side fit = math . min ( leftover horiz , leftover vert ) ; int long side fit = math . max ( leftover horiz , leftover vert ) ; if ( long side fit < best node . score 2 || ( long side fit == best node . score 2 && short side fit < best node . score 1 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = rotated width ; best node . height = rotated height ; best node . score 1 = short side fit ; best node . score 2 = long side fit ; best node . rotated = true ; } } } return best node ; } <SENTENCE_END/>

(Copy Probability: 3.7%)

<SENTENCE_START> { rect best node = new rect ( ) ; best node . score 2 = integer . max value ; for ( int i = 0 ; i < free rectangles . size ; i ++ ) { if ( free rectangles . get ( i ) . width >= width && free rectangles . get ( i ) . height >= height ) { int leftover horiz = math . abs ( free rectangles . get ( i ) . width - width ) ; int leftover vert = math . abs ( free rectangles . get ( i ) . height - height ) ; int short side fit = math . min ( leftover horiz , leftover vert ) ; int long side fit = math . max ( leftover horiz , leftover vert ) ; if ( long side fit < best node . score 2 || ( long side fit == best node . score 2 && short side fit < best node . score 1 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = width ; best node . height = height ; best node . score 1 = short side fit ; best node . score 2 = long side fit ; best node . rotated = false ; } } if ( rotate && free rectangles . get ( i ) . width >= rotated width && free rectangles . get ( i ) . height >= rotated height ) { int leftover horiz = math . abs ( free rectangles . get ( i ) . width - rotated width ) ; int leftover vert = math . abs ( free rectangles . get ( i ) . height - rotated height ) ; int short side fit = math . min ( leftover horiz , leftover vert ) ; int long side fit = math . max ( leftover horiz , leftover vert ) ; if ( long side fit < best node . score 2 || ( long side fit == best node . score 2 && short side fit < best node . score 1 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = rotated width ; best node . height = rotated height ; best node . score 1 = short side fit ; best node . score 2 = long side fit ; best node . rotated = true ; } } } return best node ; } <SENTENCE_END/>

best

<SENTENCE_START> { rect best node = new rect ( ) ; best node . score 2 = integer . max value ; for ( int i = 0 ; i < free rectangles . size ; i ++ ) { if ( free rectangles . get ( i ) . width >= width && free rectangles . get ( i ) . height >= height ) { int leftover horiz = math . abs ( free rectangles . get ( i ) . width - width ) ; int leftover vert = math . abs ( free rectangles . get ( i ) . height - height ) ; int short side fit = math . min ( leftover horiz , leftover vert ) ; int long side fit = math . max ( leftover horiz , leftover vert ) ; if ( long side fit < best node . score 2 || ( long side fit == best node . score 2 && short side fit < best node . score 1 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = width ; best node . height = height ; best node . score 1 = short side fit ; best node . score 2 = long side fit ; best node . rotated = false ; } } if ( rotate && free rectangles . get ( i ) . width >= rotated width && free rectangles . get ( i ) . height >= rotated height ) { int leftover horiz = math . abs ( free rectangles . get ( i ) . width - rotated width ) ; int leftover vert = math . abs ( free rectangles . get ( i ) . height - rotated height ) ; int short side fit = math . min ( leftover horiz , leftover vert ) ; int long side fit = math . max ( leftover horiz , leftover vert ) ; if ( long side fit < best node . score 2 || ( long side fit == best node . score 2 && short side fit < best node . score 1 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = rotated width ; best node . height = rotated height ; best node . score 1 = short side fit ; best node . score 2 = long side fit ; best node . rotated = true ; } } } return best node ; } <SENTENCE_END/>

(Copy Probability: 3.3%)

<SENTENCE_START> { rect best node = new rect ( ) ; best node . score 2 = integer . max value ; for ( int i = 0 ; i < free rectangles . size ; i ++ ) { if ( free rectangles . get ( i ) . width >= width && free rectangles . get ( i ) . height >= height ) { int leftover horiz = math . abs ( free rectangles . get ( i ) . width - width ) ; int leftover vert = math . abs ( free rectangles . get ( i ) . height - height ) ; int short side fit = math . min ( leftover horiz , leftover vert ) ; int long side fit = math . max ( leftover horiz , leftover vert ) ; if ( long side fit < best node . score 2 || ( long side fit == best node . score 2 && short side fit < best node . score 1 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = width ; best node . height = height ; best node . score 1 = short side fit ; best node . score 2 = long side fit ; best node . rotated = false ; } } if ( rotate && free rectangles . get ( i ) . width >= rotated width && free rectangles . get ( i ) . height >= rotated height ) { int leftover horiz = math . abs ( free rectangles . get ( i ) . width - rotated width ) ; int leftover vert = math . abs ( free rectangles . get ( i ) . height - rotated height ) ; int short side fit = math . min ( leftover horiz , leftover vert ) ; int long side fit = math . max ( leftover horiz , leftover vert ) ; if ( long side fit < best node . score 2 || ( long side fit == best node . score 2 && short side fit < best node . score 1 ) ) { best node . x = free rectangles . get ( i ) . x ; best node . y = free rectangles . get ( i ) . y ; best node . width = rotated width ; best node . height = rotated height ; best node . score 1 = short side fit ; best node . score 2 = long side fit ; best node . rotated = true ; } } } return best node ; } <SENTENCE_END/>

long

<SENTENCE_START> { rect best node = new rect ( ) ; best node . score 2 = integer . max value ; for ( int i = 0 ; i < free rectangles . size ; i ++ ) { if ( free rectangles . get ( i ) . width >= width && free rectangles . get ( i ) . height >= height ) { int leftover horiz = math . abs ( free rectangles . get ( i ) . width - width ) ; int leftover vert = math . abs ( free rectangles . get ( i ) . height - height ) ; int short side fit = math . min ( leftover horiz , leftover vert ) ; int long side fit = math . max ( leftover horiz , leftover vert ) ; if ( long side fit < best node . score 2