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 || ( 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.8%)

<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/>

side

<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.8%)

<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/>

fit

<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/>

%END%

<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.8%)

<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/>

Original Name find,position,for,new,node,best,area,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 ++ ) { int area fit = free rectangles . get ( i ) . width * free rectangles . get ( i ) . height - width * height ; 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 ) ; if ( area fit < best node . score 1 || ( area fit == best node . score 1 && short 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 2 = short side fit ; best node . score 1 = area 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 ) ; if ( area fit < best node . score 1 || ( area fit == best node . score 1 && short 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 2 = short side fit ; best node . score 1 = area fit ; best node . rotated = true ; } } } return best node ; } <SENTENCE_END/>

(Copy Probability: 3.5%)

<SENTENCE_START> { rect best node = new rect ( ) ; best node . score 1 = integer . max value ; for ( int i = 0 ; i < free rectangles . size ; i ++ ) { int area fit = free rectangles . get ( i ) . width * free rectangles . get ( i ) . height - width * height ; 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 ) ; if ( area fit < best node . score 1 || ( area fit == best node . score 1 && short 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 2 = short side fit ; best node . score 1 = area 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 ) ; if ( area fit < best node . score 1 || ( area fit == best node . score 1 && short 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 2 = short side fit ; best node . score 1 = area 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 ++ ) { int area fit = free rectangles . get ( i ) . width * free rectangles . get ( i ) . height - width * height ; 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 ) ; if ( area fit < best node . score 1 || ( area fit == best node . score 1 && short 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 2 = short side fit ; best node . score 1 = area 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 ) ; if ( area fit < best node . score 1 || ( area fit == best node . score 1 && short 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 2 = short side fit ; best node . score 1 = area fit ; best node . rotated = true ; } } } return best node ; } <SENTENCE_END/>

(Copy Probability: 6.8%)

<SENTENCE_START> { rect best node = new rect ( ) ; best node . score 1 = integer . max value ; for ( int i = 0 ; i < free rectangles . size ; i ++ ) { int area fit = free rectangles . get ( i ) . width * free rectangles . get ( i ) . height - width * height ; 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 ) ; if ( area fit < best node . score 1 || ( area fit == best node . score 1 && short 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 2 = short side fit ; best node . score 1 = area 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 ) ; if ( area fit < best node . score 1 || ( area fit == best node . score 1 && short 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 2 = short side fit ; best node . score 1 = area 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 ++ ) { int area fit = free rectangles . get ( i ) . width * free rectangles . get ( i ) . height - width * height ; 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 ) ; if ( area fit < best node . score 1 || ( area fit == best node . score 1 && short 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 2 = short side fit ; best node . score 1 = area 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 ) ; if ( area fit < best node . score 1 || ( area fit == best node . score 1 && short 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 2 = short side fit ; best node . score 1 = area 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 ++ ) { int area fit = free rectangles . get ( i ) . width * free rectangles . get ( i ) . height - width * height ; 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 ) ; if ( area fit < best node . score 1 || ( area fit == best node . score 1 && short 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 2 = short side fit ; best node . score 1 = area 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 ) ; if ( area fit < best node . score 1 || ( area fit == best node . score 1 && short 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 2 = short side fit ; best node . score 1 = area 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 ++ ) { int area fit = free rectangles . get ( i ) . width * free rectangles . get ( i ) . height - width * height ; 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 ) ; if ( area fit < best node . score 1 || ( area fit == best node . score 1 && short 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 2 = short side fit ; best node . score 1 = area 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 ) ; if ( area fit < best node . score 1 || ( area fit == best node . score 1 && short 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 2 = short side fit ; best node . score 1 = area fit ; best node . rotated = true ; } } } return best node ; } <SENTENCE_END/>

(Copy Probability: 3.2%)

<SENTENCE_START> { rect best node = new rect ( ) ; best node . score 1 = integer . max value ; for ( int i = 0 ; i < free rectangles . size ; i ++ ) { int area fit = free rectangles . get ( i ) . width * free rectangles . get ( i ) . height - width * height ; 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 ) ; if ( area fit < best node . score 1 || ( area fit == best node . score 1 && short 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 2 = short side fit ; best node . score 1 = area 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 ) ; if ( area fit < best node . score 1 || ( area fit == best node . score 1 && short 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 2 = short side fit ; best node . score 1 = area 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 ++ ) { int area fit = free rectangles . get ( i ) . width * free rectangles . get ( i ) . height - width * height ; 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 ) ; if ( area fit < best node . score 1 || ( area fit == best node . score 1 && short 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 2 = short side fit ; best node . score 1 = area 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 ) ; if ( area fit < best node . score 1 || ( area fit == best node . score 1 && short 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 2 = short side fit ; best node . score 1 = area 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 ++ ) { int area fit = free rectangles . get ( i ) . width * free rectangles . get ( i ) . height - width * height ; 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 ) ; if ( area fit < best node . score 1 || ( area fit == best node . score 1 && short 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 2 = short side fit ; best node . score 1 = area 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 ) ; if ( area fit < best node . score 1 || ( area fit == best node . score 1 && short 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 2 = short side fit ; best node . score 1 = area 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 ++ ) { int area fit = free rectangles . get ( i ) . width * free rectangles . get ( i ) . height - width * height ; 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 ) ; if ( area fit < best node . score 1 || ( area fit == best node . score 1 && short 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 2 = short side fit ; best node . score 1 = area 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 ) ; if ( area fit < best node . score 1 || ( area fit == best node . score 1 && short 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 2 = short side fit ; best node . score 1 = area 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 ++ ) { int area fit = free rectangles . get ( i ) . width * free rectangles . get ( i ) . height - width * height ; 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 ) ; if ( area fit < best node . score 1 || ( area fit == best node . score 1 && short 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 2 = short side fit ; best node . score 1 = area 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 ) ; if ( area fit < best node . score 1 || ( area fit == best node . score 1 && short 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 2 = short side fit ; best node . score 1 = area fit ; best node . rotated = true ; } } } return best node ; } <SENTENCE_END/>

area

<SENTENCE_START> { rect best node = new rect ( ) ; best node . score 1 = integer . max value ; for ( int i = 0 ; i < free rectangles . size ; i ++ ) { int area fit = free rectangles . get ( i ) . width * free rectangles . get ( i ) . height - width * height ; 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 ) ; if ( area fit < best node . score 1 || ( area fit == best node . score 1 && short 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 2 = short side fit ; best node . score 1 = area 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 ) ; if ( area fit < best node . score 1 || ( area fit == best node . score 1 && short 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 2 = short side fit ; best node . score 1 = area 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 ++ ) { int area fit = free rectangles . get ( i ) . width * free rectangles . get ( i ) . height - width * height ; 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 ) ; if ( area fit < best node . score 1 || ( area fit == best node . score 1 && short 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 2 = short side fit ; best node . score 1 = area 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 ) ; if ( area fit < best node . score 1 || ( area fit == best node . score 1 && short 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 2 = short side fit ; best node . score 1 = area 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 ++ ) { int area fit = free rectangles . get ( i ) . width * free rectangles . get ( i ) . height - width * height ; 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 ) ; if ( area fit < best node . score 1 || ( area fit == best node . score 1 && short 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 2 = short side fit ; best node . score 1 = area 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 ) ; if ( area fit < best node . score 1 || ( area fit == best node . score 1 && short 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 2 = short side fit ; best node . score 1 = area 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 ++ ) { int area fit = free rectangles . get ( i ) . width * free rectangles . get ( i ) . height - width * height ; 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 ) ; if ( area fit < best node . score 1 || ( area fit == best node . score 1 && short 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 2 = short side fit ; best node . score 1 = area 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 ) ; if ( area fit < best node . score 1 || ( area fit == best node . score 1 && short 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 2 = short side fit ; best node . score 1 = area 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 ++ ) { int area fit = free rectangles . get ( i ) . width * free rectangles . get ( i ) . height - width * height ; 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 ) ; if ( area fit < best node . score 1 || ( area fit == best node . score 1 && short 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 2 = short side fit ; best node . score 1 = area 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 ) ; if ( area fit < best node . score 1 || ( area fit == best node . score 1 && short 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 2 = short side fit ; best node . score 1 = area 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 ++ ) { int area fit = free rectangles . get ( i ) . width * free rectangles . get ( i ) . height - width * height ; 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 ) ; if ( area fit < best node . score 1 || ( area fit == best node . score 1 && short 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 2 = short side fit ; best node . score 1 = area 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 ) ; if ( area fit < best node . score 1 || ( area fit == best node . score 1 && short 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 2 = short side fit ; best node . score 1 = area fit ; best node . rotated = true ; } } } return best node ; } <SENTENCE_END/>

Original Name common,interval,length

common

<SENTENCE_START> { if ( i 1 end < i 2 start || i 2 end < i 1 start ) return 0 ; return math . min ( i 1 end , i 2 end ) - math . max ( i 1 start , i 2 start ) ; } <SENTENCE_END/>

(Copy Probability: 2.2%)

<SENTENCE_START> { if ( i 1 end < i 2 start || i 2 end < i 1 start ) return 0 ; return math . min ( i 1 end , i 2 end ) - math . max ( i 1 start , i 2 start ) ; } <SENTENCE_END/>

interval

<SENTENCE_START> { if ( i 1 end < i 2 start || i 2 end < i 1 start ) return 0 ; return math . min ( i 1 end , i 2 end ) - math . max ( i 1 start , i 2 start ) ; } <SENTENCE_END/>

(Copy Probability: 4.9%)

<SENTENCE_START> { if ( i 1 end < i 2 start || i 2 end < i 1 start ) return 0 ; return math . min ( i 1 end , i 2 end ) - math . max ( i 1 start , i 2 start ) ; } <SENTENCE_END/>

length

<SENTENCE_START> { if ( i 1 end < i 2 start || i 2 end < i 1 start ) return 0 ; return math . min ( i 1 end , i 2 end ) - math . max ( i 1 start , i 2 start ) ; } <SENTENCE_END/>

(Copy Probability: 2.0%)

<SENTENCE_START> { if ( i 1 end < i 2 start || i 2 end < i 1 start ) return 0 ; return math . min ( i 1 end , i 2 end ) - math . max ( i 1 start , i 2 start ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { if ( i 1 end < i 2 start || i 2 end < i 1 start ) return 0 ; return math . min ( i 1 end , i 2 end ) - math . max ( i 1 start , i 2 start ) ; } <SENTENCE_END/>

(Copy Probability: 2.9%)

<SENTENCE_START> { if ( i 1 end < i 2 start || i 2 end < i 1 start ) return 0 ; return math . min ( i 1 end , i 2 end ) - math . max ( i 1 start , i 2 start ) ; } <SENTENCE_END/>

Original Name contact,point,score,node

contact

<SENTENCE_START> { int score = 0 ; if ( x == 0 || x + width == bin width ) score += height ; if ( y == 0 || y + height == bin height ) score += width ; for ( int i = 0 ; i < used rectangles . size ; i ++ ) { if ( used rectangles . get ( i ) . x == x + width || used rectangles . get ( i ) . x + used rectangles . get ( i ) . width == x ) score += common interval length ( used rectangles . get ( i ) . y , used rectangles . get ( i ) . y + used rectangles . get ( i ) . height , y , y + height ) ; if ( used rectangles . get ( i ) . y == y + height || used rectangles . get ( i ) . y + used rectangles . get ( i ) . height == y ) score += common interval length ( used rectangles . get ( i ) . x , used rectangles . get ( i ) . x + used rectangles . get ( i ) . width , x , x + width ) ; } return score ; } <SENTENCE_END/>

(Copy Probability: 4.8%)

<SENTENCE_START> { int score = 0 ; if ( x == 0 || x + width == bin width ) score += height ; if ( y == 0 || y + height == bin height ) score += width ; for ( int i = 0 ; i < used rectangles . size ; i ++ ) { if ( used rectangles . get ( i ) . x == x + width || used rectangles . get ( i ) . x + used rectangles . get ( i ) . width == x ) score += common interval length ( used rectangles . get ( i ) . y , used rectangles . get ( i ) . y + used rectangles . get ( i ) . height , y , y + height ) ; if ( used rectangles . get ( i ) . y == y + height || used rectangles . get ( i ) . y + used rectangles . get ( i ) . height == y ) score += common interval length ( used rectangles . get ( i ) . x , used rectangles . get ( i ) . x + used rectangles . get ( i ) . width , x , x + width ) ; } return score ; } <SENTENCE_END/>

point

<SENTENCE_START> { int score = 0 ; if ( x == 0 || x + width == bin width ) score += height ; if ( y == 0 || y + height == bin height ) score += width ; for ( int i = 0 ; i < used rectangles . size ; i ++ ) { if ( used rectangles . get ( i ) . x == x + width || used rectangles . get ( i ) . x + used rectangles . get ( i ) . width == x ) score += common interval length ( used rectangles . get ( i ) . y , used rectangles . get ( i ) . y + used rectangles . get ( i ) . height , y , y + height ) ; if ( used rectangles . get ( i ) . y == y + height || used rectangles . get ( i ) . y + used rectangles . get ( i ) . height == y ) score += common interval length ( used rectangles . get ( i ) . x , used rectangles . get ( i ) . x + used rectangles . get ( i ) . width , x , x + width ) ; } return score ; } <SENTENCE_END/>

(Copy Probability: 37.4%)

<SENTENCE_START> { int score = 0 ; if ( x == 0 || x + width == bin width ) score += height ; if ( y == 0 || y + height == bin height ) score += width ; for ( int i = 0 ; i < used rectangles . size ; i ++ ) { if ( used rectangles . get ( i ) . x == x + width || used rectangles . get ( i ) . x + used rectangles . get ( i ) . width == x ) score += common interval length ( used rectangles . get ( i ) . y , used rectangles . get ( i ) . y + used rectangles . get ( i ) . height , y , y + height ) ; if ( used rectangles . get ( i ) . y == y + height || used rectangles . get ( i ) . y + used rectangles . get ( i ) . height == y ) score += common interval length ( used rectangles . get ( i ) . x , used rectangles . get ( i ) . x + used rectangles . get ( i ) . width , x , x + width ) ; } return score ; } <SENTENCE_END/>

score

<SENTENCE_START> { int score = 0 ; if ( x == 0 || x + width == bin width ) score += height ; if ( y == 0 || y + height == bin height ) score += width ; for ( int i = 0 ; i < used rectangles . size ; i ++ ) { if ( used rectangles . get ( i ) . x == x + width || used rectangles . get ( i ) . x + used rectangles . get ( i ) . width == x ) score += common interval length ( used rectangles . get ( i ) . y , used rectangles . get ( i ) . y + used rectangles . get ( i ) . height , y , y + height ) ; if ( used rectangles . get ( i ) . y == y + height || used rectangles . get ( i ) . y + used rectangles . get ( i ) . height == y ) score += common interval length ( used rectangles . get ( i ) . x , used rectangles . get ( i ) . x + used rectangles . get ( i ) . width , x , x + width ) ; } return score ; } <SENTENCE_END/>

(Copy Probability: 36.2%)

<SENTENCE_START> { int score = 0 ; if ( x == 0 || x + width == bin width ) score += height ; if ( y == 0 || y + height == bin height ) score += width ; for ( int i = 0 ; i < used rectangles . size ; i ++ ) { if ( used rectangles . get ( i ) . x == x + width || used rectangles . get ( i ) . x + used rectangles . get ( i ) . width == x ) score += common interval length ( used rectangles . get ( i ) . y , used rectangles . get ( i ) . y + used rectangles . get ( i ) . height , y , y + height ) ; if ( used rectangles . get ( i ) . y == y + height || used rectangles . get ( i ) . y + used rectangles . get ( i ) . height == y ) score += common interval length ( used rectangles . get ( i ) . x , used rectangles . get ( i ) . x + used rectangles . get ( i ) . width , x , x + width ) ; } return score ; } <SENTENCE_END/>

node

<SENTENCE_START> { int score = 0 ; if ( x == 0 || x + width == bin width ) score += height ; if ( y == 0 || y + height == bin height ) score += width ; for ( int i = 0 ; i < used rectangles . size ; i ++ ) { if ( used rectangles . get ( i ) . x == x + width || used rectangles . get ( i ) . x + used rectangles . get ( i ) . width == x ) score += common interval length ( used rectangles . get ( i ) . y , used rectangles . get ( i ) . y + used rectangles . get ( i ) . height , y , y + height ) ; if ( used rectangles . get ( i ) . y == y + height || used rectangles . get ( i ) . y + used rectangles . get ( i ) . height == y ) score += common interval length ( used rectangles . get ( i ) . x , used rectangles . get ( i ) . x + used rectangles . get ( i ) . width , x , x + width ) ; } return score ; } <SENTENCE_END/>

(Copy Probability: 8.4%)

<SENTENCE_START> { int score = 0 ; if ( x == 0 || x + width == bin width ) score += height ; if ( y == 0 || y + height == bin height ) score += width ; for ( int i = 0 ; i < used rectangles . size ; i ++ ) { if ( used rectangles . get ( i ) . x == x + width || used rectangles . get ( i ) . x + used rectangles . get ( i ) . width == x ) score += common interval length ( used rectangles . get ( i ) . y , used rectangles . get ( i ) . y + used rectangles . get ( i ) . height , y , y + height ) ; if ( used rectangles . get ( i ) . y == y + height || used rectangles . get ( i ) . y + used rectangles . get ( i ) . height == y ) score += common interval length ( used rectangles . get ( i ) . x , used rectangles . get ( i ) . x + used rectangles . get ( i ) . width , x , x + width ) ; } return score ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { int score = 0 ; if ( x == 0 || x + width == bin width ) score += height ; if ( y == 0 || y + height == bin height ) score += width ; for ( int i = 0 ; i < used rectangles . size ; i ++ ) { if ( used rectangles . get ( i ) . x == x + width || used rectangles . get ( i ) . x + used rectangles . get ( i ) . width == x ) score += common interval length ( used rectangles . get ( i ) . y , used rectangles . get ( i ) . y + used rectangles . get ( i ) . height , y , y + height ) ; if ( used rectangles . get ( i ) . y == y + height || used rectangles . get ( i ) . y + used rectangles . get ( i ) . height == y ) score += common interval length ( used rectangles . get ( i ) . x , used rectangles . get ( i ) . x + used rectangles . get ( i ) . width , x , x + width ) ; } return score ; } <SENTENCE_END/>

(Copy Probability: 5.0%)

<SENTENCE_START> { int score = 0 ; if ( x == 0 || x + width == bin width ) score += height ; if ( y == 0 || y + height == bin height ) score += width ; for ( int i = 0 ; i < used rectangles . size ; i ++ ) { if ( used rectangles . get ( i ) . x == x + width || used rectangles . get ( i ) . x + used rectangles . get ( i ) . width == x ) score += common interval length ( used rectangles . get ( i ) . y , used rectangles . get ( i ) . y + used rectangles . get ( i ) . height , y , y + height ) ; if ( used rectangles . get ( i ) . y == y + height || used rectangles . get ( i ) . y + used rectangles . get ( i ) . height == y ) score += common interval length ( used rectangles . get ( i ) . x , used rectangles . get ( i ) . x + used rectangles . get ( i ) . width , x , x + width ) ; } return score ; } <SENTENCE_END/>

Original Name find,position,for,new,node,contact,point

find

<SENTENCE_START> { rect best node = new rect ( ) ; best node . score 1 = - 1 ; for ( int i = 0 ; i < free rectangles . size ; i ++ ) { if ( free rectangles . get ( i ) . width >= width && free rectangles . get ( i ) . height >= height ) { int score = contact point score node ( free rectangles . get ( i ) . x , free rectangles . get ( i ) . y , width , height ) ; if ( score > 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 = score ; best node . rotated = false ; } } if ( rotate && free rectangles . get ( i ) . width >= rotated width && free rectangles . get ( i ) . height >= rotated height ) { int score = contact point score node ( free rectangles . get ( i ) . x , free rectangles . get ( i ) . y , rotated width , rotated height ) ; if ( score > 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 = score ; best node . rotated = true ; } } } return best node ; } <SENTENCE_END/>

(Copy Probability: 3.3%)

<SENTENCE_START> { rect best node = new rect ( ) ; best node . score 1 = - 1 ; for ( int i = 0 ; i < free rectangles . size ; i ++ ) { if ( free rectangles . get ( i ) . width >= width && free rectangles . get ( i ) . height >= height ) { int score = contact point score node ( free rectangles . get ( i ) . x , free rectangles . get ( i ) . y , width , height ) ; if ( score > 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 = score ; best node . rotated = false ; } } if ( rotate && free rectangles . get ( i ) . width >= rotated width && free rectangles . get ( i ) . height >= rotated height ) { int score = contact point score node ( free rectangles . get ( i ) . x , free rectangles . get ( i ) . y , rotated width , rotated height ) ; if ( score > 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 = score ; best node . rotated = true ; } } } return best node ; } <SENTENCE_END/>

position

<SENTENCE_START> { rect best node = new rect ( ) ; best node . score 1 = - 1 ; for ( int i = 0 ; i < free rectangles . size ; i ++ ) { if ( free rectangles . get ( i ) . width >= width && free rectangles . get ( i ) . height >= height ) { int score = contact point score node ( free rectangles . get ( i ) . x , free rectangles . get ( i ) . y , width , height ) ; if ( score > 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 = score ; best node . rotated = false ; } } if ( rotate && free rectangles . get ( i ) . width >= rotated width && free rectangles . get ( i ) . height >= rotated height ) { int score = contact point score node ( free rectangles . get ( i ) . x , free rectangles . get ( i ) . y , rotated width , rotated height ) ; if ( score > 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 = score ; best node . rotated = true ; } } } return best node ; } <SENTENCE_END/>

(Copy Probability: 11.2%)

<SENTENCE_START> { rect best node = new rect ( ) ; best node . score 1 = - 1 ; for ( int i = 0 ; i < free rectangles . size ; i ++ ) { if ( free rectangles . get ( i ) . width >= width && free rectangles . get ( i ) . height >= height ) { int score = contact point score node ( free rectangles . get ( i ) . x , free rectangles . get ( i ) . y , width , height ) ; if ( score > 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 = score ; best node . rotated = false ; } } if ( rotate && free rectangles . get ( i ) . width >= rotated width && free rectangles . get ( i ) . height >= rotated height ) { int score = contact point score node ( free rectangles . get ( i ) . x , free rectangles . get ( i ) . y , rotated width , rotated height ) ; if ( score > 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 = score ; best node . rotated = true ; } } } return best node ; } <SENTENCE_END/>

for

<SENTENCE_START> { rect best node = new rect ( ) ; best node . score 1 = - 1 ; for ( int i = 0 ; i < free rectangles . size ; i ++ ) { if ( free rectangles . get ( i ) . width >= width && free rectangles . get ( i ) . height >= height ) { int score = contact point score node ( free rectangles . get ( i ) . x , free rectangles . get ( i ) . y , width , height ) ; if ( score > 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 = score ; best node . rotated = false ; } } if ( rotate && free rectangles . get ( i ) . width >= rotated width && free rectangles . get ( i ) . height >= rotated height ) { int score = contact point score node ( free rectangles . get ( i ) . x , free rectangles . get ( i ) . y , rotated width , rotated height ) ; if ( score > 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 = score ; best node . rotated = true ; } } } return best node ; } <SENTENCE_END/>

(Copy Probability: 5.6%)

<SENTENCE_START> { rect best node = new rect ( ) ; best node . score 1 = - 1 ; for ( int i = 0 ; i < free rectangles . size ; i ++ ) { if ( free rectangles . get ( i ) . width >= width && free rectangles . get ( i ) . height >= height ) { int score = contact point score node ( free rectangles . get ( i ) . x , free rectangles . get ( i ) . y , width , height ) ; if ( score > 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 = score ; best node . rotated = false ; } } if ( rotate && free rectangles . get ( i ) . width >= rotated width && free rectangles . get ( i ) . height >= rotated height ) { int score = contact point score node ( free rectangles . get ( i ) . x , free rectangles . get ( i ) . y , rotated width , rotated height ) ; if ( score > 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 = score ; best node . rotated = true ; } } } return best node ; } <SENTENCE_END/>

new

<SENTENCE_START> { rect best node = new rect ( ) ; best node . score 1 = - 1 ; for ( int i = 0 ; i < free rectangles . size ; i ++ ) { if ( free rectangles . get ( i ) . width >= width && free rectangles . get ( i ) . height >= height ) { int score = contact point score node ( free rectangles . get ( i ) . x , free rectangles . get ( i ) . y , width , height ) ; if ( score > 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 = score ; best node . rotated = false ; } } if ( rotate && free rectangles . get ( i ) . width >= rotated width && free rectangles . get ( i ) . height >= rotated height ) { int score = contact point score node ( free rectangles . get ( i ) . x , free rectangles . get ( i ) . y , rotated width , rotated height ) ; if ( score > 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 = score ; best node . rotated = true ; } } } return best node ; } <SENTENCE_END/>

(Copy Probability: 4.1%)

<SENTENCE_START> { rect best node = new rect ( ) ; best node . score 1 = - 1 ; for ( int i = 0 ; i < free rectangles . size ; i ++ ) { if ( free rectangles . get ( i ) . width >= width && free rectangles . get ( i ) . height >= height ) { int score = contact point score node ( free rectangles . get ( i ) . x , free rectangles . get ( i ) . y , width , height ) ; if ( score > 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 = score ; best node . rotated = false ; } } if ( rotate && free rectangles . get ( i ) . width >= rotated width && free rectangles . get ( i ) . height >= rotated height ) { int score = contact point score node ( free rectangles . get ( i ) . x , free rectangles . get ( i ) . y , rotated width , rotated height ) ; if ( score > 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 = score ; best node . rotated = true ; } } } return best node ; } <SENTENCE_END/>

node

<SENTENCE_START> { rect best node = new rect ( ) ; best node . score 1 = - 1 ; for ( int i = 0 ; i < free rectangles . size ; i ++ ) { if ( free rectangles . get ( i ) . width >= width && free rectangles . get ( i ) . height >= height ) { int score = contact point score node ( free rectangles . get ( i ) . x , free rectangles . get ( i ) . y , width , height ) ; if ( score > 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 = score ; best node . rotated = false ; } } if ( rotate && free rectangles . get ( i ) . width >= rotated width && free rectangles . get ( i ) . height >= rotated height ) { int score = contact point score node ( free rectangles . get ( i ) . x , free rectangles . get ( i ) . y , rotated width , rotated height ) ; if ( score > 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 = score ; best node . rotated = true ; } } } return best node ; } <SENTENCE_END/>

(Copy Probability: 3.8%)

<SENTENCE_START> { rect best node = new rect ( ) ; best node . score 1 = - 1 ; for ( int i = 0 ; i < free rectangles . size ; i ++ ) { if ( free rectangles . get ( i ) . width >= width && free rectangles . get ( i ) . height >= height ) { int score = contact point score node ( free rectangles . get ( i ) . x , free rectangles . get ( i ) . y , width , height ) ; if ( score > 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 = score ; best node . rotated = false ; } } if ( rotate && free rectangles . get ( i ) . width >= rotated width && free rectangles . get ( i ) . height >= rotated height ) { int score = contact point score node ( free rectangles . get ( i ) . x , free rectangles . get ( i ) . y , rotated width , rotated height ) ; if ( score > 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 = score ; best node . rotated = true ; } } } return best node ; } <SENTENCE_END/>

contact

<SENTENCE_START> { rect best node = new rect ( ) ; best node . score 1 = - 1 ; for ( int i = 0 ; i < free rectangles . size ; i ++ ) { if ( free rectangles . get ( i ) . width >= width && free rectangles . get ( i ) . height >= height ) { int score = contact point score node ( free rectangles . get ( i ) . x , free rectangles . get ( i ) . y , width , height ) ; if ( score > 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 = score ; best node . rotated = false ; } } if ( rotate && free rectangles . get ( i ) . width >= rotated width && free rectangles . get ( i ) . height >= rotated height ) { int score = contact point score node ( free rectangles . get ( i ) . x , free rectangles . get ( i ) . y , rotated width , rotated height ) ; if ( score > 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 = score ; best node . rotated = true ; } } } return best node ; } <SENTENCE_END/>

(Copy Probability: 3.9%)

<SENTENCE_START> { rect best node = new rect ( ) ; best node . score 1 = - 1 ; for ( int i = 0 ; i < free rectangles . size ; i ++ ) { if ( free rectangles . get ( i ) . width >= width && free rectangles . get ( i ) . height >= height ) { int score = contact point score node ( free rectangles . get ( i ) . x , free rectangles . get ( i ) . y , width , height ) ; if ( score > 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 = score ; best node . rotated = false ; } } if ( rotate && free rectangles . get ( i ) . width >= rotated width && free rectangles . get ( i ) . height >= rotated height ) { int score = contact point score node ( free rectangles . get ( i ) . x , free rectangles . get ( i ) . y , rotated width , rotated height ) ; if ( score > 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 = score ; best node . rotated = true ; } } } return best node ; } <SENTENCE_END/>

point

<SENTENCE_START> { rect best node = new rect ( ) ; best node . score 1 = - 1 ; for ( int i = 0 ; i < free rectangles . size ; i ++ ) { if ( free rectangles . get ( i ) . width >= width && free rectangles . get ( i ) . height >= height ) { int score = contact point score node ( free rectangles . get ( i ) . x , free rectangles . get ( i ) . y , width , height ) ; if ( score > 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 = score ; best node . rotated = false ; } } if ( rotate && free rectangles . get ( i ) . width >= rotated width && free rectangles . get ( i ) . height >= rotated height ) { int score = contact point score node ( free rectangles . get ( i ) . x , free rectangles . get ( i ) . y , rotated width , rotated height ) ; if ( score > 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 = score ; best node . rotated = true ; } } } return best node ; } <SENTENCE_END/>

(Copy Probability: 3.9%)

<SENTENCE_START> { rect best node = new rect ( ) ; best node . score 1 = - 1 ; for ( int i = 0 ; i < free rectangles . size ; i ++ ) { if ( free rectangles . get ( i ) . width >= width && free rectangles . get ( i ) . height >= height ) { int score = contact point score node ( free rectangles . get ( i ) . x , free rectangles . get ( i ) . y , width , height ) ; if ( score > 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 = score ; best node . rotated = false ; } } if ( rotate && free rectangles . get ( i ) . width >= rotated width && free rectangles . get ( i ) . height >= rotated height ) { int score = contact point score node ( free rectangles . get ( i ) . x , free rectangles . get ( i ) . y , rotated width , rotated height ) ; if ( score > 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 = score ; best node . rotated = true ; } } } return best node ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { rect best node = new rect ( ) ; best node . score 1 = - 1 ; for ( int i = 0 ; i < free rectangles . size ; i ++ ) { if ( free rectangles . get ( i ) . width >= width && free rectangles . get ( i ) . height >= height ) { int score = contact point score node ( free rectangles . get ( i ) . x , free rectangles . get ( i ) . y , width , height ) ; if ( score > 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 = score ; best node . rotated = false ; } } if ( rotate && free rectangles . get ( i ) . width >= rotated width && free rectangles . get ( i ) . height >= rotated height ) { int score = contact point score node ( free rectangles . get ( i ) . x , free rectangles . get ( i ) . y , rotated width , rotated height ) ; if ( score > 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 = score ; best node . rotated = true ; } } } return best node ; } <SENTENCE_END/>

(Copy Probability: 3.9%)

<SENTENCE_START> { rect best node = new rect ( ) ; best node . score 1 = - 1 ; for ( int i = 0 ; i < free rectangles . size ; i ++ ) { if ( free rectangles . get ( i ) . width >= width && free rectangles . get ( i ) . height >= height ) { int score = contact point score node ( free rectangles . get ( i ) . x , free rectangles . get ( i ) . y , width , height ) ; if ( score > 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 = score ; best node . rotated = false ; } } if ( rotate && free rectangles . get ( i ) . width >= rotated width && free rectangles . get ( i ) . height >= rotated height ) { int score = contact point score node ( free rectangles . get ( i ) . x , free rectangles . get ( i ) . y , rotated width , rotated height ) ; if ( score > 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 = score ; best node . rotated = true ; } } } return best node ; } <SENTENCE_END/>

Original Name split,free,node

split

<SENTENCE_START> { if ( used node . x >= free node . x + free node . width || used node . x + used node . width <= free node . x || used node . y >= free node . y + free node . height || used node . y + used node . height <= free node . y ) return false ; if ( used node . x < free node . x + free node . width && used node . x + used node . width > free node . x ) { if ( used node . y > free node . y && used node . y < free node . y + free node . height ) { rect new node = new rect ( free node ) ; new node . height = used node . y - new node . y ; free rectangles . add ( new node ) ; } if ( used node . y + used node . height < free node . y + free node . height ) { rect new node = new rect ( free node ) ; new node . y = used node . y + used node . height ; new node . height = free node . y + free node . height - ( used node . y + used node . height ) ; free rectangles . add ( new node ) ; } } if ( used node . y < free node . y + free node . height && used node . y + used node . height > free node . y ) { if ( used node . x > free node . x && used node . x < free node . x + free node . width ) { rect new node = new rect ( free node ) ; new node . width = used node . x - new node . x ; free rectangles . add ( new node ) ; } if ( used node . x + used node . width < free node . x + free node . width ) { rect new node = new rect ( free node ) ; new node . x = used node . x + used node . width ; new node . width = free node . x + free node . width - ( used node . x + used node . width ) ; free rectangles . add ( new node ) ; } } return true ; } <SENTENCE_END/>

(Copy Probability: 3.5%)

<SENTENCE_START> { if ( used node . x >= free node . x + free node . width || used node . x + used node . width <= free node . x || used node . y >= free node . y + free node . height || used node . y + used node . height <= free node . y ) return false ; if ( used node . x < free node . x + free node . width && used node . x + used node . width > free node . x ) { if ( used node . y > free node . y && used node . y < free node . y + free node . height ) { rect new node = new rect ( free node ) ; new node . height = used node . y - new node . y ; free rectangles . add ( new node ) ; } if ( used node . y + used node . height < free node . y + free node . height ) { rect new node = new rect ( free node ) ; new node . y = used node . y + used node . height ; new node . height = free node . y + free node . height - ( used node . y + used node . height ) ; free rectangles . add ( new node ) ; } } if ( used node . y < free node . y + free node . height && used node . y + used node . height > free node . y ) { if ( used node . x > free node . x && used node . x < free node . x + free node . width ) { rect new node = new rect ( free node ) ; new node . width = used node . x - new node . x ; free rectangles . add ( new node ) ; } if ( used node . x + used node . width < free node . x + free node . width ) { rect new node = new rect ( free node ) ; new node . x = used node . x + used node . width ; new node . width = free node . x + free node . width - ( used node . x + used node . width ) ; free rectangles . add ( new node ) ; } } return true ; } <SENTENCE_END/>

free

<SENTENCE_START> { if ( used node . x >= free node . x + free node . width || used node . x + used node . width <= free node . x || used node . y >= free node . y + free node . height || used node . y + used node . height <= free node . y ) return false ; if ( used node . x < free node . x + free node . width && used node . x + used node . width > free node . x ) { if ( used node . y > free node . y && used node . y < free node . y + free node . height ) { rect new node = new rect ( free node ) ; new node . height = used node . y - new node . y ; free rectangles . add ( new node ) ; } if ( used node . y + used node . height < free node . y + free node . height ) { rect new node = new rect ( free node ) ; new node . y = used node . y + used node . height ; new node . height = free node . y + free node . height - ( used node . y + used node . height ) ; free rectangles . add ( new node ) ; } } if ( used node . y < free node . y + free node . height && used node . y + used node . height > free node . y ) { if ( used node . x > free node . x && used node . x < free node . x + free node . width ) { rect new node = new rect ( free node ) ; new node . width = used node . x - new node . x ; free rectangles . add ( new node ) ; } if ( used node . x + used node . width < free node . x + free node . width ) { rect new node = new rect ( free node ) ; new node . x = used node . x + used node . width ; new node . width = free node . x + free node . width - ( used node . x + used node . width ) ; free rectangles . add ( new node ) ; } } return true ; } <SENTENCE_END/>

(Copy Probability: 17.3%)

<SENTENCE_START> { if ( used node . x >= free node . x + free node . width || used node . x + used node . width <= free node . x || used node . y >= free node . y + free node . height || used node . y + used node . height <= free node . y ) return false ; if ( used node . x < free node . x + free node . width && used node . x + used node . width > free node . x ) { if ( used node . y > free node . y && used node . y < free node . y + free node . height ) { rect new node = new rect ( free node ) ; new node . height = used node . y - new node . y ; free rectangles . add ( new node ) ; } if ( used node . y + used node . height < free node . y + free node . height ) { rect new node = new rect ( free node ) ; new node . y = used node . y + used node . height ; new node . height = free node . y + free node . height - ( used node . y + used node . height ) ; free rectangles . add ( new node ) ; } } if ( used node . y < free node . y + free node . height && used node . y + used node . height > free node . y ) { if ( used node . x > free node . x && used node . x < free node . x + free node . width ) { rect new node = new rect ( free node ) ; new node . width = used node . x - new node . x ; free rectangles . add ( new node ) ; } if ( used node . x + used node . width < free node . x + free node . width ) { rect new node = new rect ( free node ) ; new node . x = used node . x + used node . width ; new node . width = free node . x + free node . width - ( used node . x + used node . width ) ; free rectangles . add ( new node ) ; } } return true ; } <SENTENCE_END/>

node

<SENTENCE_START> { if ( used node . x >= free node . x + free node . width || used node . x + used node . width <= free node . x || used node . y >= free node . y + free node . height || used node . y + used node . height <= free node . y ) return false ; if ( used node . x < free node . x + free node . width && used node . x + used node . width > free node . x ) { if ( used node . y > free node . y && used node . y < free node . y + free node . height ) { rect new node = new rect ( free node ) ; new node . height = used node . y - new node . y ; free rectangles . add ( new node ) ; } if ( used node . y + used node . height < free node . y + free node . height ) { rect new node = new rect ( free node ) ; new node . y = used node . y + used node . height ; new node . height = free node . y + free node . height - ( used node . y + used node . height ) ; free rectangles . add ( new node ) ; } } if ( used node . y < free node . y + free node . height && used node . y + used node . height > free node . y ) { if ( used node . x > free node . x && used node . x < free node . x + free node . width ) { rect new node = new rect ( free node ) ; new node . width = used node . x - new node . x ; free rectangles . add ( new node ) ; } if ( used node . x + used node . width < free node . x + free node . width ) { rect new node = new rect ( free node ) ; new node . x = used node . x + used node . width ; new node . width = free node . x + free node . width - ( used node . x + used node . width ) ; free rectangles . add ( new node ) ; } } return true ; } <SENTENCE_END/>

(Copy Probability: 6.8%)

<SENTENCE_START> { if ( used node . x >= free node . x + free node . width || used node . x + used node . width <= free node . x || used node . y >= free node . y + free node . height || used node . y + used node . height <= free node . y ) return false ; if ( used node . x < free node . x + free node . width && used node . x + used node . width > free node . x ) { if ( used node . y > free node . y && used node . y < free node . y + free node . height ) { rect new node = new rect ( free node ) ; new node . height = used node . y - new node . y ; free rectangles . add ( new node ) ; } if ( used node . y + used node . height < free node . y + free node . height ) { rect new node = new rect ( free node ) ; new node . y = used node . y + used node . height ; new node . height = free node . y + free node . height - ( used node . y + used node . height ) ; free rectangles . add ( new node ) ; } } if ( used node . y < free node . y + free node . height && used node . y + used node . height > free node . y ) { if ( used node . x > free node . x && used node . x < free node . x + free node . width ) { rect new node = new rect ( free node ) ; new node . width = used node . x - new node . x ; free rectangles . add ( new node ) ; } if ( used node . x + used node . width < free node . x + free node . width ) { rect new node = new rect ( free node ) ; new node . x = used node . x + used node . width ; new node . width = free node . x + free node . width - ( used node . x + used node . width ) ; free rectangles . add ( new node ) ; } } return true ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { if ( used node . x >= free node . x + free node . width || used node . x + used node . width <= free node . x || used node . y >= free node . y + free node . height || used node . y + used node . height <= free node . y ) return false ; if ( used node . x < free node . x + free node . width && used node . x + used node . width > free node . x ) { if ( used node . y > free node . y && used node . y < free node . y + free node . height ) { rect new node = new rect ( free node ) ; new node . height = used node . y - new node . y ; free rectangles . add ( new node ) ; } if ( used node . y + used node . height < free node . y + free node . height ) { rect new node = new rect ( free node ) ; new node . y = used node . y + used node . height ; new node . height = free node . y + free node . height - ( used node . y + used node . height ) ; free rectangles . add ( new node ) ; } } if ( used node . y < free node . y + free node . height && used node . y + used node . height > free node . y ) { if ( used node . x > free node . x && used node . x < free node . x + free node . width ) { rect new node = new rect ( free node ) ; new node . width = used node . x - new node . x ; free rectangles . add ( new node ) ; } if ( used node . x + used node . width < free node . x + free node . width ) { rect new node = new rect ( free node ) ; new node . x = used node . x + used node . width ; new node . width = free node . x + free node . width - ( used node . x + used node . width ) ; free rectangles . add ( new node ) ; } } return true ; } <SENTENCE_END/>

(Copy Probability: 3.7%)

<SENTENCE_START> { if ( used node . x >= free node . x + free node . width || used node . x + used node . width <= free node . x || used node . y >= free node . y + free node . height || used node . y + used node . height <= free node . y ) return false ; if ( used node . x < free node . x + free node . width && used node . x + used node . width > free node . x ) { if ( used node . y > free node . y && used node . y < free node . y + free node . height ) { rect new node = new rect ( free node ) ; new node . height = used node . y - new node . y ; free rectangles . add ( new node ) ; } if ( used node . y + used node . height < free node . y + free node . height ) { rect new node = new rect ( free node ) ; new node . y = used node . y + used node . height ; new node . height = free node . y + free node . height - ( used node . y + used node . height ) ; free rectangles . add ( new node ) ; } } if ( used node . y < free node . y + free node . height && used node . y + used node . height > free node . y ) { if ( used node . x > free node . x && used node . x < free node . x + free node . width ) { rect new node = new rect ( free node ) ; new node . width = used node . x - new node . x ; free rectangles . add ( new node ) ; } if ( used node . x + used node . width < free node . x + free node . width ) { rect new node = new rect ( free node ) ; new node . x = used node . x + used node . width ; new node . width = free node . x + free node . width - ( used node . x + used node . width ) ; free rectangles . add ( new node ) ; } } return true ; } <SENTENCE_END/>

Original Name prune,free,list

prune

<SENTENCE_START> { for ( int i = 0 ; i < free rectangles . size ; i ++ ) for ( int j = i + 1 ; j < free rectangles . size ; ++ j ) { if ( is contained in ( free rectangles . get ( i ) , free rectangles . get ( j ) ) ) { free rectangles . remove index ( i ) ; -- i ; break ; } if ( is contained in ( free rectangles . get ( j ) , free rectangles . get ( i ) ) ) { free rectangles . remove index ( j ) ; -- j ; } } } <SENTENCE_END/>

(Copy Probability: 3.1%)

<SENTENCE_START> { for ( int i = 0 ; i < free rectangles . size ; i ++ ) for ( int j = i + 1 ; j < free rectangles . size ; ++ j ) { if ( is contained in ( free rectangles . get ( i ) , free rectangles . get ( j ) ) ) { free rectangles . remove index ( i ) ; -- i ; break ; } if ( is contained in ( free rectangles . get ( j ) , free rectangles . get ( i ) ) ) { free rectangles . remove index ( j ) ; -- j ; } } } <SENTENCE_END/>

free

<SENTENCE_START> { for ( int i = 0 ; i < free rectangles . size ; i ++ ) for ( int j = i + 1 ; j < free rectangles . size ; ++ j ) { if ( is contained in ( free rectangles . get ( i ) , free rectangles . get ( j ) ) ) { free rectangles . remove index ( i ) ; -- i ; break ; } if ( is contained in ( free rectangles . get ( j ) , free rectangles . get ( i ) ) ) { free rectangles . remove index ( j ) ; -- j ; } } } <SENTENCE_END/>

(Copy Probability: 6.7%)

<SENTENCE_START> { for ( int i = 0 ; i < free rectangles . size ; i ++ ) for ( int j = i + 1 ; j < free rectangles . size ; ++ j ) { if ( is contained in ( free rectangles . get ( i ) , free rectangles . get ( j ) ) ) { free rectangles . remove index ( i ) ; -- i ; break ; } if ( is contained in ( free rectangles . get ( j ) , free rectangles . get ( i ) ) ) { free rectangles . remove index ( j ) ; -- j ; } } } <SENTENCE_END/>

list

<SENTENCE_START> { for ( int i = 0 ; i < free rectangles . size ; i ++ ) for ( int j = i + 1 ; j < free rectangles . size ; ++ j ) { if ( is contained in ( free rectangles . get ( i ) , free rectangles . get ( j ) ) ) { free rectangles . remove index ( i ) ; -- i ; break ; } if ( is contained in ( free rectangles . get ( j ) , free rectangles . get ( i ) ) ) { free rectangles . remove index ( j ) ; -- j ; } } } <SENTENCE_END/>

(Copy Probability: 5.5%)

<SENTENCE_START> { for ( int i = 0 ; i < free rectangles . size ; i ++ ) for ( int j = i + 1 ; j < free rectangles . size ; ++ j ) { if ( is contained in ( free rectangles . get ( i ) , free rectangles . get ( j ) ) ) { free rectangles . remove index ( i ) ; -- i ; break ; } if ( is contained in ( free rectangles . get ( j ) , free rectangles . get ( i ) ) ) { free rectangles . remove index ( j ) ; -- j ; } } } <SENTENCE_END/>

%END%

<SENTENCE_START> { for ( int i = 0 ; i < free rectangles . size ; i ++ ) for ( int j = i + 1 ; j < free rectangles . size ; ++ j ) { if ( is contained in ( free rectangles . get ( i ) , free rectangles . get ( j ) ) ) { free rectangles . remove index ( i ) ; -- i ; break ; } if ( is contained in ( free rectangles . get ( j ) , free rectangles . get ( i ) ) ) { free rectangles . remove index ( j ) ; -- j ; } } } <SENTENCE_END/>

(Copy Probability: 4.1%)

<SENTENCE_START> { for ( int i = 0 ; i < free rectangles . size ; i ++ ) for ( int j = i + 1 ; j < free rectangles . size ; ++ j ) { if ( is contained in ( free rectangles . get ( i ) , free rectangles . get ( j ) ) ) { free rectangles . remove index ( i ) ; -- i ; break ; } if ( is contained in ( free rectangles . get ( j ) , free rectangles . get ( i ) ) ) { free rectangles . remove index ( j ) ; -- j ; } } } <SENTENCE_END/>

Original Name is,contained,in

is

<SENTENCE_START> { return a . x >= b . x && a . y >= b . y && a . x + a . width <= b . x + b . width && a . y + a . height <= b . y + b . height ; } <SENTENCE_END/>

(Copy Probability: 1.5%)

<SENTENCE_START> { return a . x >= b . x && a . y >= b . y && a . x + a . width <= b . x + b . width && a . y + a . height <= b . y + b . height ; } <SENTENCE_END/>

contained

<SENTENCE_START> { return a . x >= b . x && a . y >= b . y && a . x + a . width <= b . x + b . width && a . y + a . height <= b . y + b . height ; } <SENTENCE_END/>

(Copy Probability: 1.2%)

<SENTENCE_START> { return a . x >= b . x && a . y >= b . y && a . x + a . width <= b . x + b . width && a . y + a . height <= b . y + b . height ; } <SENTENCE_END/>

in

<SENTENCE_START> { return a . x >= b . x && a . y >= b . y && a . x + a . width <= b . x + b . width && a . y + a . height <= b . y + b . height ; } <SENTENCE_END/>

(Copy Probability: 1.6%)

<SENTENCE_START> { return a . x >= b . x && a . y >= b . y && a . x + a . width <= b . x + b . width && a . y + a . height <= b . y + b . height ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return a . x >= b . x && a . y >= b . y && a . x + a . width <= b . x + b . width && a . y + a . height <= b . y + b . height ; } <SENTENCE_END/>

(Copy Probability: 2.6%)

<SENTENCE_START> { return a . x >= b . x && a . y >= b . y && a . x + a . width <= b . x + b . width && a . y + a . height <= b . y + b . height ; } <SENTENCE_END/>

Original Name compare

compare

<SENTENCE_START> { return rect . get atlas name ( o 1 . name , settings . flatten paths ) . compare to ( rect . get atlas name ( o 2 . name , settings . flatten paths ) ) ; } <SENTENCE_END/>

(Copy Probability: 1.9%)

<SENTENCE_START> { return rect . get atlas name ( o 1 . name , settings . flatten paths ) . compare to ( rect . get atlas name ( o 2 . name , settings . flatten paths ) ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return rect . get atlas name ( o 1 . name , settings . flatten paths ) . compare to ( rect . get atlas name ( o 2 . name , settings . flatten paths ) ) ; } <SENTENCE_END/>

(Copy Probability: 37.5%)

<SENTENCE_START> { return rect . get atlas name ( o 1 . name , settings . flatten paths ) . compare to ( rect . get atlas name ( o 2 . name , settings . flatten paths ) ) ; } <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,type,constraint,data

set

<SENTENCE_START> { dynamics jni . bt slider constraint double data type constraint data set ( swig c ptr , this , bt typed constraint double data . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

(Copy Probability: 1.5%)

<SENTENCE_START> { dynamics jni . bt slider constraint double data type constraint data set ( swig c ptr , this , bt typed constraint double data . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

type

<SENTENCE_START> { dynamics jni . bt slider constraint double data type constraint data set ( swig c ptr , this , bt typed constraint double data . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

(Copy Probability: 99.9%)

<SENTENCE_START> { dynamics jni . bt slider constraint double data type constraint data set ( swig c ptr , this , bt typed constraint double data . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

constraint

<SENTENCE_START> { dynamics jni . bt slider constraint double data type constraint data set ( swig c ptr , this , bt typed constraint double data . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

(Copy Probability: 99.9%)

<SENTENCE_START> { dynamics jni . bt slider constraint double data type constraint data set ( swig c ptr , this , bt typed constraint double data . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

data

<SENTENCE_START> { dynamics jni . bt slider constraint double data type constraint data set ( swig c ptr , this , bt typed constraint double data . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

(Copy Probability: 86.0%)

<SENTENCE_START> { dynamics jni . bt slider constraint double data type constraint data set ( swig c ptr , this , bt typed constraint double data . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { dynamics jni . bt slider constraint double data type constraint data set ( swig c ptr , this , bt typed constraint double data . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

(Copy Probability: 6.3%)

<SENTENCE_START> { dynamics jni . bt slider constraint double data type constraint data set ( swig c ptr , this , bt typed constraint double data . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

Original Name get,type,constraint,data

get

<SENTENCE_START> { long c ptr = dynamics jni . bt slider constraint double data type constraint data get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt typed constraint double data ( c ptr , false ) ; } <SENTENCE_END/>

(Copy Probability: 1.9%)

<SENTENCE_START> { long c ptr = dynamics jni . bt slider constraint double data type constraint data get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt typed constraint double data ( c ptr , false ) ; } <SENTENCE_END/>

type

<SENTENCE_START> { long c ptr = dynamics jni . bt slider constraint double data type constraint data get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt typed constraint double data ( c ptr , false ) ; } <SENTENCE_END/>

(Copy Probability: 99.8%)

<SENTENCE_START> { long c ptr = dynamics jni . bt slider constraint double data type constraint data get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt typed constraint double data ( c ptr , false ) ; } <SENTENCE_END/>

constraint

<SENTENCE_START> { long c ptr = dynamics jni . bt slider constraint double data type constraint data get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt typed constraint double data ( c ptr , false ) ; } <SENTENCE_END/>

(Copy Probability: 99.9%)

<SENTENCE_START> { long c ptr = dynamics jni . bt slider constraint double data type constraint data get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt typed constraint double data ( c ptr , false ) ; } <SENTENCE_END/>

data

<SENTENCE_START> { long c ptr = dynamics jni . bt slider constraint double data type constraint data get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt typed constraint double data ( c ptr , false ) ; } <SENTENCE_END/>

(Copy Probability: 81.0%)

<SENTENCE_START> { long c ptr = dynamics jni . bt slider constraint double data type constraint data get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt typed constraint double data ( c ptr , false ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { long c ptr = dynamics jni . bt slider constraint double data type constraint data get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt typed constraint double data ( c ptr , false ) ; } <SENTENCE_END/>

(Copy Probability: 5.9%)

<SENTENCE_START> { long c ptr = dynamics jni . bt slider constraint double data type constraint data get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt typed constraint double data ( c ptr , false ) ; } <SENTENCE_END/>

Original Name set,rb,a,frame

set

<SENTENCE_START> { dynamics jni . bt slider constraint double data rb a frame set ( swig c ptr , this , bt transform double data . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

(Copy Probability: 2.7%)

<SENTENCE_START> { dynamics jni . bt slider constraint double data rb a frame set ( swig c ptr , this , bt transform double data . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

rb

<SENTENCE_START> { dynamics jni . bt slider constraint double data rb a frame set ( swig c ptr , this , bt transform double data . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

(Copy Probability: 99.9%)

<SENTENCE_START> { dynamics jni . bt slider constraint double data rb a frame set ( swig c ptr , this , bt transform double data . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

a

<SENTENCE_START> { dynamics jni . bt slider constraint double data rb a frame set ( swig c ptr , this , bt transform double data . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

(Copy Probability: 100.0%)

<SENTENCE_START> { dynamics jni . bt slider constraint double data rb a frame set ( swig c ptr , this , bt transform double data . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

frame

<SENTENCE_START> { dynamics jni . bt slider constraint double data rb a frame set ( swig c ptr , this , bt transform double data . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

(Copy Probability: 96.8%)

<SENTENCE_START> { dynamics jni . bt slider constraint double data rb a frame set ( swig c ptr , this , bt transform double data . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { dynamics jni . bt slider constraint double data rb a frame set ( swig c ptr , this , bt transform double data . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

(Copy Probability: 10.1%)

<SENTENCE_START> { dynamics jni . bt slider constraint double data rb a frame set ( swig c ptr , this , bt transform double data . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

Original Name get,rb,a,frame

get

<SENTENCE_START> { long c ptr = dynamics jni . bt slider constraint double data rb a frame get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt transform double data ( c ptr , false ) ; } <SENTENCE_END/>

(Copy Probability: 2.7%)

<SENTENCE_START> { long c ptr = dynamics jni . bt slider constraint double data rb a frame get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt transform double data ( c ptr , false ) ; } <SENTENCE_END/>

rb

<SENTENCE_START> { long c ptr = dynamics jni . bt slider constraint double data rb a frame get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt transform double data ( c ptr , false ) ; } <SENTENCE_END/>

(Copy Probability: 99.9%)

<SENTENCE_START> { long c ptr = dynamics jni . bt slider constraint double data rb a frame get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt transform double data ( c ptr , false ) ; } <SENTENCE_END/>

a

<SENTENCE_START> { long c ptr = dynamics jni . bt slider constraint double data rb a frame get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt transform double data ( c ptr , false ) ; } <SENTENCE_END/>

(Copy Probability: 100.0%)

<SENTENCE_START> { long c ptr = dynamics jni . bt slider constraint double data rb a frame get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt transform double data ( c ptr , false ) ; } <SENTENCE_END/>

frame

<SENTENCE_START> { long c ptr = dynamics jni . bt slider constraint double data rb a frame get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt transform double data ( c ptr , false ) ; } <SENTENCE_END/>

(Copy Probability: 96.1%)

<SENTENCE_START> { long c ptr = dynamics jni . bt slider constraint double data rb a frame get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt transform double data ( c ptr , false ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { long c ptr = dynamics jni . bt slider constraint double data rb a frame get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt transform double data ( c ptr , false ) ; } <SENTENCE_END/>

(Copy Probability: 9.9%)

<SENTENCE_START> { long c ptr = dynamics jni . bt slider constraint double data rb a frame get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt transform double data ( c ptr , false ) ; } <SENTENCE_END/>

Original Name set,rb,b,frame

set

<SENTENCE_START> { dynamics jni . bt slider constraint double data rb b frame set ( swig c ptr , this , bt transform double data . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

(Copy Probability: 2.5%)

<SENTENCE_START> { dynamics jni . bt slider constraint double data rb b frame set ( swig c ptr , this , bt transform double data . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

rb

<SENTENCE_START> { dynamics jni . bt slider constraint double data rb b frame set ( swig c ptr , this , bt transform double data . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

(Copy Probability: 99.9%)

<SENTENCE_START> { dynamics jni . bt slider constraint double data rb b frame set ( swig c ptr , this , bt transform double data . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

b

<SENTENCE_START> { dynamics jni . bt slider constraint double data rb b frame set ( swig c ptr , this , bt transform double data . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

(Copy Probability: 100.0%)

<SENTENCE_START> { dynamics jni . bt slider constraint double data rb b frame set ( swig c ptr , this , bt transform double data . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

frame

<SENTENCE_START> { dynamics jni . bt slider constraint double data rb b frame set ( swig c ptr , this , bt transform double data . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

(Copy Probability: 95.9%)

<SENTENCE_START> { dynamics jni . bt slider constraint double data rb b frame set ( swig c ptr , this , bt transform double data . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { dynamics jni . bt slider constraint double data rb b frame set ( swig c ptr , this , bt transform double data . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

(Copy Probability: 17.4%)

<SENTENCE_START> { dynamics jni . bt slider constraint double data rb b frame set ( swig c ptr , this , bt transform double data . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

Original Name get,rb,b,frame

get

<SENTENCE_START> { long c ptr = dynamics jni . bt slider constraint double data rb b frame get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt transform double data ( c ptr , false ) ; } <SENTENCE_END/>

(Copy Probability: 2.5%)

<SENTENCE_START> { long c ptr = dynamics jni . bt slider constraint double data rb b frame get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt transform double data ( c ptr , false ) ; } <SENTENCE_END/>

rb

<SENTENCE_START> { long c ptr = dynamics jni . bt slider constraint double data rb b frame get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt transform double data ( c ptr , false ) ; } <SENTENCE_END/>

(Copy Probability: 99.9%)

<SENTENCE_START> { long c ptr = dynamics jni . bt slider constraint double data rb b frame get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt transform double data ( c ptr , false ) ; } <SENTENCE_END/>

b

<SENTENCE_START> { long c ptr = dynamics jni . bt slider constraint double data rb b frame get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt transform double data ( c ptr , false ) ; } <SENTENCE_END/>

(Copy Probability: 100.0%)

<SENTENCE_START> { long c ptr = dynamics jni . bt slider constraint double data rb b frame get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt transform double data ( c ptr , false ) ; } <SENTENCE_END/>

frame

<SENTENCE_START> { long c ptr = dynamics jni . bt slider constraint double data rb b frame get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt transform double data ( c ptr , false ) ; } <SENTENCE_END/>

(Copy Probability: 94.9%)

<SENTENCE_START> { long c ptr = dynamics jni . bt slider constraint double data rb b frame get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt transform double data ( c ptr , false ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { long c ptr = dynamics jni . bt slider constraint double data rb b frame get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt transform double data ( c ptr , false ) ; } <SENTENCE_END/>

(Copy Probability: 16.2%)

<SENTENCE_START> { long c ptr = dynamics jni . bt slider constraint double data rb b frame get ( swig c ptr , this ) ; return ( c ptr == 0 ) ? null : new bt transform double data ( c ptr , false ) ; } <SENTENCE_END/>

Original Name set,linear,upper,limit

set

<SENTENCE_START> { dynamics jni . bt slider constraint double data linear upper limit set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 2.1%)

<SENTENCE_START> { dynamics jni . bt slider constraint double data linear upper limit set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

linear

<SENTENCE_START> { dynamics jni . bt slider constraint double data linear upper limit set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 99.8%)

<SENTENCE_START> { dynamics jni . bt slider constraint double data linear upper limit set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

upper

<SENTENCE_START> { dynamics jni . bt slider constraint double data linear upper limit set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 100.0%)

<SENTENCE_START> { dynamics jni . bt slider constraint double data linear upper limit set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

limit

<SENTENCE_START> { dynamics jni . bt slider constraint double data linear upper limit set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 93.9%)

<SENTENCE_START> { dynamics jni . bt slider constraint double data linear upper limit set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { dynamics jni . bt slider constraint double data linear upper limit set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 8.8%)

<SENTENCE_START> { dynamics jni . bt slider constraint double data linear upper limit set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

Original Name get,linear,upper,limit

get

<SENTENCE_START> { return dynamics jni . bt slider constraint double data linear upper limit get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 1.9%)

<SENTENCE_START> { return dynamics jni . bt slider constraint double data linear upper limit get ( swig c ptr , this ) ; } <SENTENCE_END/>

linear

<SENTENCE_START> { return dynamics jni . bt slider constraint double data linear upper limit get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 99.8%)

<SENTENCE_START> { return dynamics jni . bt slider constraint double data linear upper limit get ( swig c ptr , this ) ; } <SENTENCE_END/>

upper

<SENTENCE_START> { return dynamics jni . bt slider constraint double data linear upper limit get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 100.0%)

<SENTENCE_START> { return dynamics jni . bt slider constraint double data linear upper limit get ( swig c ptr , this ) ; } <SENTENCE_END/>

limit

<SENTENCE_START> { return dynamics jni . bt slider constraint double data linear upper limit get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 94.3%)

<SENTENCE_START> { return dynamics jni . bt slider constraint double data linear upper limit get ( swig c ptr , this ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return dynamics jni . bt slider constraint double data linear upper limit get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 9.0%)

<SENTENCE_START> { return dynamics jni . bt slider constraint double data linear upper limit get ( swig c ptr , this ) ; } <SENTENCE_END/>

Original Name set,linear,lower,limit

set

<SENTENCE_START> { dynamics jni . bt slider constraint double data linear lower limit set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 2.0%)

<SENTENCE_START> { dynamics jni . bt slider constraint double data linear lower limit set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

linear

<SENTENCE_START> { dynamics jni . bt slider constraint double data linear lower limit set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 99.8%)

<SENTENCE_START> { dynamics jni . bt slider constraint double data linear lower limit set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

lower

<SENTENCE_START> { dynamics jni . bt slider constraint double data linear lower limit set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 100.0%)

<SENTENCE_START> { dynamics jni . bt slider constraint double data linear lower limit set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

limit

<SENTENCE_START> { dynamics jni . bt slider constraint double data linear lower limit set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 94.1%)

<SENTENCE_START> { dynamics jni . bt slider constraint double data linear lower limit set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { dynamics jni . bt slider constraint double data linear lower limit set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 8.5%)

<SENTENCE_START> { dynamics jni . bt slider constraint double data linear lower limit set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

Original Name get,linear,lower,limit

get

<SENTENCE_START> { return dynamics jni . bt slider constraint double data linear lower limit get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 1.8%)

<SENTENCE_START> { return dynamics jni . bt slider constraint double data linear lower limit get ( swig c ptr , this ) ; } <SENTENCE_END/>

linear

<SENTENCE_START> { return dynamics jni . bt slider constraint double data linear lower limit get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 99.8%)

<SENTENCE_START> { return dynamics jni . bt slider constraint double data linear lower limit get ( swig c ptr , this ) ; } <SENTENCE_END/>

lower

<SENTENCE_START> { return dynamics jni . bt slider constraint double data linear lower limit get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 100.0%)

<SENTENCE_START> { return dynamics jni . bt slider constraint double data linear lower limit get ( swig c ptr , this ) ; } <SENTENCE_END/>

limit

<SENTENCE_START> { return dynamics jni . bt slider constraint double data linear lower limit get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 94.3%)

<SENTENCE_START> { return dynamics jni . bt slider constraint double data linear lower limit get ( swig c ptr , this ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return dynamics jni . bt slider constraint double data linear lower limit get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 8.6%)

<SENTENCE_START> { return dynamics jni . bt slider constraint double data linear lower limit get ( swig c ptr , this ) ; } <SENTENCE_END/>

Original Name set,angular,upper,limit

set

<SENTENCE_START> { dynamics jni . bt slider constraint double data angular upper limit set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 2.0%)

<SENTENCE_START> { dynamics jni . bt slider constraint double data angular upper limit set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

angular

<SENTENCE_START> { dynamics jni . bt slider constraint double data angular upper limit set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 99.8%)

<SENTENCE_START> { dynamics jni . bt slider constraint double data angular upper limit set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

upper

<SENTENCE_START> { dynamics jni . bt slider constraint double data angular upper limit set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 100.0%)

<SENTENCE_START> { dynamics jni . bt slider constraint double data angular upper limit set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

limit

<SENTENCE_START> { dynamics jni . bt slider constraint double data angular upper limit set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 93.0%)

<SENTENCE_START> { dynamics jni . bt slider constraint double data angular upper limit set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { dynamics jni . bt slider constraint double data angular upper limit set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 8.9%)

<SENTENCE_START> { dynamics jni . bt slider constraint double data angular upper limit set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

Original Name get,angular,upper,limit

get

<SENTENCE_START> { return dynamics jni . bt slider constraint double data angular upper limit get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 1.8%)

<SENTENCE_START> { return dynamics jni . bt slider constraint double data angular upper limit get ( swig c ptr , this ) ; } <SENTENCE_END/>

angular

<SENTENCE_START> { return dynamics jni . bt slider constraint double data angular upper limit get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 99.8%)

<SENTENCE_START> { return dynamics jni . bt slider constraint double data angular upper limit get ( swig c ptr , this ) ; } <SENTENCE_END/>

upper

<SENTENCE_START> { return dynamics jni . bt slider constraint double data angular upper limit get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 100.0%)

<SENTENCE_START> { return dynamics jni . bt slider constraint double data angular upper limit get ( swig c ptr , this ) ; } <SENTENCE_END/>

limit

<SENTENCE_START> { return dynamics jni . bt slider constraint double data angular upper limit get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 93.7%)

<SENTENCE_START> { return dynamics jni . bt slider constraint double data angular upper limit get ( swig c ptr , this ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return dynamics jni . bt slider constraint double data angular upper limit get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 9.5%)

<SENTENCE_START> { return dynamics jni . bt slider constraint double data angular upper limit get ( swig c ptr , this ) ; } <SENTENCE_END/>

Original Name set,angular,lower,limit

set

<SENTENCE_START> { dynamics jni . bt slider constraint double data angular lower limit set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 1.9%)

<SENTENCE_START> { dynamics jni . bt slider constraint double data angular lower limit set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

angular

<SENTENCE_START> { dynamics jni . bt slider constraint double data angular lower limit set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 99.8%)

<SENTENCE_START> { dynamics jni . bt slider constraint double data angular lower limit set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

lower

<SENTENCE_START> { dynamics jni . bt slider constraint double data angular lower limit set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 100.0%)

<SENTENCE_START> { dynamics jni . bt slider constraint double data angular lower limit set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

limit

<SENTENCE_START> { dynamics jni . bt slider constraint double data angular lower limit set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 93.1%)

<SENTENCE_START> { dynamics jni . bt slider constraint double data angular lower limit set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { dynamics jni . bt slider constraint double data angular lower limit set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 8.6%)

<SENTENCE_START> { dynamics jni . bt slider constraint double data angular lower limit set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

Original Name get,angular,lower,limit

get

<SENTENCE_START> { return dynamics jni . bt slider constraint double data angular lower limit get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 1.7%)

<SENTENCE_START> { return dynamics jni . bt slider constraint double data angular lower limit get ( swig c ptr , this ) ; } <SENTENCE_END/>

angular

<SENTENCE_START> { return dynamics jni . bt slider constraint double data angular lower limit get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 99.8%)

<SENTENCE_START> { return dynamics jni . bt slider constraint double data angular lower limit get ( swig c ptr , this ) ; } <SENTENCE_END/>

lower

<SENTENCE_START> { return dynamics jni . bt slider constraint double data angular lower limit get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 100.0%)

<SENTENCE_START> { return dynamics jni . bt slider constraint double data angular lower limit get ( swig c ptr , this ) ; } <SENTENCE_END/>

limit

<SENTENCE_START> { return dynamics jni . bt slider constraint double data angular lower limit get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 93.8%)

<SENTENCE_START> { return dynamics jni . bt slider constraint double data angular lower limit get ( swig c ptr , this ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return dynamics jni . bt slider constraint double data angular lower limit get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 9.0%)

<SENTENCE_START> { return dynamics jni . bt slider constraint double data angular lower limit get ( swig c ptr , this ) ; } <SENTENCE_END/>

Original Name set,use,linear,reference,frame,a

set

<SENTENCE_START> { dynamics jni . bt slider constraint double data use linear reference frame a set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 3.3%)

<SENTENCE_START> { dynamics jni . bt slider constraint double data use linear reference frame a set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

use

<SENTENCE_START> { dynamics jni . bt slider constraint double data use linear reference frame a set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 99.8%)

<SENTENCE_START> { dynamics jni . bt slider constraint double data use linear reference frame a set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

linear

<SENTENCE_START> { dynamics jni . bt slider constraint double data use linear reference frame a set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 99.9%)

<SENTENCE_START> { dynamics jni . bt slider constraint double data use linear reference frame a set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

reference

<SENTENCE_START> { dynamics jni . bt slider constraint double data use linear reference frame a set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 99.7%)

<SENTENCE_START> { dynamics jni . bt slider constraint double data use linear reference frame a set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

frame

<SENTENCE_START> { dynamics jni . bt slider constraint double data use linear reference frame a set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 98.9%)

<SENTENCE_START> { dynamics jni . bt slider constraint double data use linear reference frame a set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

a

<SENTENCE_START> { dynamics jni . bt slider constraint double data use linear reference frame a set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 51.5%)

<SENTENCE_START> { dynamics jni . bt slider constraint double data use linear reference frame a set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { dynamics jni . bt slider constraint double data use linear reference frame a set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 28.6%)

<SENTENCE_START> { dynamics jni . bt slider constraint double data use linear reference frame a set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

Original Name get,use,linear,reference,frame,a

get

<SENTENCE_START> { return dynamics jni . bt slider constraint double data use linear reference frame a get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 2.6%)

<SENTENCE_START> { return dynamics jni . bt slider constraint double data use linear reference frame a get ( swig c ptr , this ) ; } <SENTENCE_END/>

use

<SENTENCE_START> { return dynamics jni . bt slider constraint double data use linear reference frame a get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 99.8%)

<SENTENCE_START> { return dynamics jni . bt slider constraint double data use linear reference frame a get ( swig c ptr , this ) ; } <SENTENCE_END/>

linear

<SENTENCE_START> { return dynamics jni . bt slider constraint double data use linear reference frame a get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 99.9%)

<SENTENCE_START> { return dynamics jni . bt slider constraint double data use linear reference frame a get ( swig c ptr , this ) ; } <SENTENCE_END/>

reference

<SENTENCE_START> { return dynamics jni . bt slider constraint double data use linear reference frame a get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 99.7%)

<SENTENCE_START> { return dynamics jni . bt slider constraint double data use linear reference frame a get ( swig c ptr , this ) ; } <SENTENCE_END/>

frame

<SENTENCE_START> { return dynamics jni . bt slider constraint double data use linear reference frame a get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 98.8%)

<SENTENCE_START> { return dynamics jni . bt slider constraint double data use linear reference frame a get ( swig c ptr , this ) ; } <SENTENCE_END/>

a

<SENTENCE_START> { return dynamics jni . bt slider constraint double data use linear reference frame a get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 50.3%)

<SENTENCE_START> { return dynamics jni . bt slider constraint double data use linear reference frame a get ( swig c ptr , this ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return dynamics jni . bt slider constraint double data use linear reference frame a get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 26.1%)

<SENTENCE_START> { return dynamics jni . bt slider constraint double data use linear reference frame a get ( swig c ptr , this ) ; } <SENTENCE_END/>

Original Name set,use,offset,for,constraint,frame

set

<SENTENCE_START> { dynamics jni . bt slider constraint double data use offset for constraint frame set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 2.8%)

<SENTENCE_START> { dynamics jni . bt slider constraint double data use offset for constraint frame set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

use

<SENTENCE_START> { dynamics jni . bt slider constraint double data use offset for constraint frame set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 99.8%)

<SENTENCE_START> { dynamics jni . bt slider constraint double data use offset for constraint frame set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

offset

<SENTENCE_START> { dynamics jni . bt slider constraint double data use offset for constraint frame set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 99.9%)

<SENTENCE_START> { dynamics jni . bt slider constraint double data use offset for constraint frame set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

for

<SENTENCE_START> { dynamics jni . bt slider constraint double data use offset for constraint frame set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 99.6%)

<SENTENCE_START> { dynamics jni . bt slider constraint double data use offset for constraint frame set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

constraint

<SENTENCE_START> { dynamics jni . bt slider constraint double data use offset for constraint frame set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 68.8%)

<SENTENCE_START> { dynamics jni . bt slider constraint double data use offset for constraint frame set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

frame

<SENTENCE_START> { dynamics jni . bt slider constraint double data use offset for constraint frame set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 33.2%)

<SENTENCE_START> { dynamics jni . bt slider constraint double data use offset for constraint frame set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { dynamics jni . bt slider constraint double data use offset for constraint frame set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 32.3%)

<SENTENCE_START> { dynamics jni . bt slider constraint double data use offset for constraint frame set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

Original Name get,use,offset,for,constraint,frame

get

<SENTENCE_START> { return dynamics jni . bt slider constraint double data use offset for constraint frame get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 2.3%)

<SENTENCE_START> { return dynamics jni . bt slider constraint double data use offset for constraint frame get ( swig c ptr , this ) ; } <SENTENCE_END/>

use

<SENTENCE_START> { return dynamics jni . bt slider constraint double data use offset for constraint frame get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 99.8%)

<SENTENCE_START> { return dynamics jni . bt slider constraint double data use offset for constraint frame get ( swig c ptr , this ) ; } <SENTENCE_END/>

offset

<SENTENCE_START> { return dynamics jni . bt slider constraint double data use offset for constraint frame get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 99.9%)

<SENTENCE_START> { return dynamics jni . bt slider constraint double data use offset for constraint frame get ( swig c ptr , this ) ; } <SENTENCE_END/>

for

<SENTENCE_START> { return dynamics jni . bt slider constraint double data use offset for constraint frame get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 99.6%)

<SENTENCE_START> { return dynamics jni . bt slider constraint double data use offset for constraint frame get ( swig c ptr , this ) ; } <SENTENCE_END/>

constraint

<SENTENCE_START> { return dynamics jni . bt slider constraint double data use offset for constraint frame get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 67.8%)

<SENTENCE_START> { return dynamics jni . bt slider constraint double data use offset for constraint frame get ( swig c ptr , this ) ; } <SENTENCE_END/>

frame

<SENTENCE_START> { return dynamics jni . bt slider constraint double data use offset for constraint frame get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 32.0%)

<SENTENCE_START> { return dynamics jni . bt slider constraint double data use offset for constraint frame get ( swig c ptr , this ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return dynamics jni . bt slider constraint double data use offset for constraint frame get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 30.2%)

<SENTENCE_START> { return dynamics jni . bt slider constraint double data use offset for constraint frame 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,lo,limit

set

<SENTENCE_START> { dynamics jni . bt rotational limit motor lo limit set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 1.2%)

<SENTENCE_START> { dynamics jni . bt rotational limit motor lo limit set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

lo

<SENTENCE_START> { dynamics jni . bt rotational limit motor lo limit set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 99.5%)

<SENTENCE_START> { dynamics jni . bt rotational limit motor lo limit set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

limit

<SENTENCE_START> { dynamics jni . bt rotational limit motor lo limit set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 87.6%)

<SENTENCE_START> { dynamics jni . bt rotational limit motor lo limit set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { dynamics jni . bt rotational limit motor lo limit set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 4.1%)

<SENTENCE_START> { dynamics jni . bt rotational limit motor lo limit set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

Original Name get,lo,limit

get

<SENTENCE_START> { return dynamics jni . bt rotational limit motor lo limit get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 1.3%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor lo limit get ( swig c ptr , this ) ; } <SENTENCE_END/>

lo

<SENTENCE_START> { return dynamics jni . bt rotational limit motor lo limit get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 99.4%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor lo limit get ( swig c ptr , this ) ; } <SENTENCE_END/>

limit

<SENTENCE_START> { return dynamics jni . bt rotational limit motor lo limit get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 94.0%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor lo limit get ( swig c ptr , this ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return dynamics jni . bt rotational limit motor lo limit get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 3.6%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor lo limit get ( swig c ptr , this ) ; } <SENTENCE_END/>

Original Name set,hi,limit

set

<SENTENCE_START> { dynamics jni . bt rotational limit motor hi limit set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 1.0%)

<SENTENCE_START> { dynamics jni . bt rotational limit motor hi limit set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

hi

<SENTENCE_START> { dynamics jni . bt rotational limit motor hi limit set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 99.7%)

<SENTENCE_START> { dynamics jni . bt rotational limit motor hi limit set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

limit

<SENTENCE_START> { dynamics jni . bt rotational limit motor hi limit set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 55.6%)

<SENTENCE_START> { dynamics jni . bt rotational limit motor hi limit set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { dynamics jni . bt rotational limit motor hi limit set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 3.8%)

<SENTENCE_START> { dynamics jni . bt rotational limit motor hi limit set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

Original Name get,hi,limit

get

<SENTENCE_START> { return dynamics jni . bt rotational limit motor hi limit get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 1.0%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor hi limit get ( swig c ptr , this ) ; } <SENTENCE_END/>

hi

<SENTENCE_START> { return dynamics jni . bt rotational limit motor hi limit get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 99.7%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor hi limit get ( swig c ptr , this ) ; } <SENTENCE_END/>

limit

<SENTENCE_START> { return dynamics jni . bt rotational limit motor hi limit get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 79.0%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor hi limit get ( swig c ptr , this ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return dynamics jni . bt rotational limit motor hi limit get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 3.3%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor hi limit get ( swig c ptr , this ) ; } <SENTENCE_END/>

Original Name set,target,velocity

set

<SENTENCE_START> { dynamics jni . bt rotational limit motor target velocity set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 1.4%)

<SENTENCE_START> { dynamics jni . bt rotational limit motor target velocity set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

target

<SENTENCE_START> { dynamics jni . bt rotational limit motor target velocity set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 99.7%)

<SENTENCE_START> { dynamics jni . bt rotational limit motor target velocity set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

velocity

<SENTENCE_START> { dynamics jni . bt rotational limit motor target velocity set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 95.9%)

<SENTENCE_START> { dynamics jni . bt rotational limit motor target velocity set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { dynamics jni . bt rotational limit motor target velocity set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 3.3%)

<SENTENCE_START> { dynamics jni . bt rotational limit motor target velocity set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

Original Name get,target,velocity

get

<SENTENCE_START> { return dynamics jni . bt rotational limit motor target velocity get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 1.4%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor target velocity get ( swig c ptr , this ) ; } <SENTENCE_END/>

target

<SENTENCE_START> { return dynamics jni . bt rotational limit motor target velocity get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 99.7%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor target velocity get ( swig c ptr , this ) ; } <SENTENCE_END/>

velocity

<SENTENCE_START> { return dynamics jni . bt rotational limit motor target velocity get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 98.4%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor target velocity get ( swig c ptr , this ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return dynamics jni . bt rotational limit motor target velocity get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 3.4%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor target velocity get ( swig c ptr , this ) ; } <SENTENCE_END/>

Original Name set,max,motor,force

set

<SENTENCE_START> { dynamics jni . bt rotational limit motor max motor force set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 1.6%)

<SENTENCE_START> { dynamics jni . bt rotational limit motor max motor force set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

max

<SENTENCE_START> { dynamics jni . bt rotational limit motor max motor force set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 99.8%)

<SENTENCE_START> { dynamics jni . bt rotational limit motor max motor force set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

motor

<SENTENCE_START> { dynamics jni . bt rotational limit motor max motor force set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 99.9%)

<SENTENCE_START> { dynamics jni . bt rotational limit motor max motor force set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

force

<SENTENCE_START> { dynamics jni . bt rotational limit motor max motor force set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 81.9%)

<SENTENCE_START> { dynamics jni . bt rotational limit motor max motor force set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { dynamics jni . bt rotational limit motor max motor force set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 6.5%)

<SENTENCE_START> { dynamics jni . bt rotational limit motor max motor force set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

Original Name get,max,motor,force

get

<SENTENCE_START> { return dynamics jni . bt rotational limit motor max motor force get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 1.5%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor max motor force get ( swig c ptr , this ) ; } <SENTENCE_END/>

max

<SENTENCE_START> { return dynamics jni . bt rotational limit motor max motor force get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 99.8%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor max motor force get ( swig c ptr , this ) ; } <SENTENCE_END/>

motor

<SENTENCE_START> { return dynamics jni . bt rotational limit motor max motor force get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 99.9%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor max motor force get ( swig c ptr , this ) ; } <SENTENCE_END/>

force

<SENTENCE_START> { return dynamics jni . bt rotational limit motor max motor force get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 83.6%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor max motor force get ( swig c ptr , this ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return dynamics jni . bt rotational limit motor max motor force get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 7.2%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor max motor force get ( swig c ptr , this ) ; } <SENTENCE_END/>

Original Name set,max,limit,force

set

<SENTENCE_START> { dynamics jni . bt rotational limit motor max limit force set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 1.5%)

<SENTENCE_START> { dynamics jni . bt rotational limit motor max limit force set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

max

<SENTENCE_START> { dynamics jni . bt rotational limit motor max limit force set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 99.8%)

<SENTENCE_START> { dynamics jni . bt rotational limit motor max limit force set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

limit

<SENTENCE_START> { dynamics jni . bt rotational limit motor max limit force set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 99.9%)

<SENTENCE_START> { dynamics jni . bt rotational limit motor max limit force set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

force

<SENTENCE_START> { dynamics jni . bt rotational limit motor max limit force set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 68.4%)

<SENTENCE_START> { dynamics jni . bt rotational limit motor max limit force set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { dynamics jni . bt rotational limit motor max limit force set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 6.7%)

<SENTENCE_START> { dynamics jni . bt rotational limit motor max limit force set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

Original Name get,max,limit,force

get

<SENTENCE_START> { return dynamics jni . bt rotational limit motor max limit force get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 1.5%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor max limit force get ( swig c ptr , this ) ; } <SENTENCE_END/>

max

<SENTENCE_START> { return dynamics jni . bt rotational limit motor max limit force get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 99.8%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor max limit force get ( swig c ptr , this ) ; } <SENTENCE_END/>

limit

<SENTENCE_START> { return dynamics jni . bt rotational limit motor max limit force get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 99.9%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor max limit force get ( swig c ptr , this ) ; } <SENTENCE_END/>

force

<SENTENCE_START> { return dynamics jni . bt rotational limit motor max limit force get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 71.1%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor max limit force get ( swig c ptr , this ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return dynamics jni . bt rotational limit motor max limit force get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 7.2%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor max limit force get ( swig c ptr , this ) ; } <SENTENCE_END/>

Original Name set,damping

set

<SENTENCE_START> { dynamics jni . bt rotational limit motor damping set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 1.1%)

<SENTENCE_START> { dynamics jni . bt rotational limit motor damping set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

damping

<SENTENCE_START> { dynamics jni . bt rotational limit motor damping set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 99.5%)

<SENTENCE_START> { dynamics jni . bt rotational limit motor damping set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { dynamics jni . bt rotational limit motor damping set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 0.7%)

<SENTENCE_START> { dynamics jni . bt rotational limit motor damping set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

Original Name get,damping

get

<SENTENCE_START> { return dynamics jni . bt rotational limit motor damping get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 1.3%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor damping get ( swig c ptr , this ) ; } <SENTENCE_END/>

damping

<SENTENCE_START> { return dynamics jni . bt rotational limit motor damping get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 99.3%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor damping get ( swig c ptr , this ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return dynamics jni . bt rotational limit motor damping get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 0.6%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor damping get ( swig c ptr , this ) ; } <SENTENCE_END/>

Original Name set,limit,softness

set

<SENTENCE_START> { dynamics jni . bt rotational limit motor limit softness set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 1.2%)

<SENTENCE_START> { dynamics jni . bt rotational limit motor limit softness set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

limit

<SENTENCE_START> { dynamics jni . bt rotational limit motor limit softness set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 99.8%)

<SENTENCE_START> { dynamics jni . bt rotational limit motor limit softness set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

softness

<SENTENCE_START> { dynamics jni . bt rotational limit motor limit softness set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 66.7%)

<SENTENCE_START> { dynamics jni . bt rotational limit motor limit softness set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { dynamics jni . bt rotational limit motor limit softness set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 2.5%)

<SENTENCE_START> { dynamics jni . bt rotational limit motor limit softness set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

Original Name get,limit,softness

get

<SENTENCE_START> { return dynamics jni . bt rotational limit motor limit softness get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 1.3%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor limit softness get ( swig c ptr , this ) ; } <SENTENCE_END/>

limit

<SENTENCE_START> { return dynamics jni . bt rotational limit motor limit softness get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 99.8%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor limit softness get ( swig c ptr , this ) ; } <SENTENCE_END/>

softness

<SENTENCE_START> { return dynamics jni . bt rotational limit motor limit softness get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 81.9%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor limit softness get ( swig c ptr , this ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return dynamics jni . bt rotational limit motor limit softness get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 2.3%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor limit softness get ( swig c ptr , this ) ; } <SENTENCE_END/>

Original Name set,normal,cfm

set

<SENTENCE_START> { dynamics jni . bt rotational limit motor normal cfm set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 1.3%)

<SENTENCE_START> { dynamics jni . bt rotational limit motor normal cfm set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

normal

<SENTENCE_START> { dynamics jni . bt rotational limit motor normal cfm set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 99.8%)

<SENTENCE_START> { dynamics jni . bt rotational limit motor normal cfm set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

cfm

<SENTENCE_START> { dynamics jni . bt rotational limit motor normal cfm set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 68.9%)

<SENTENCE_START> { dynamics jni . bt rotational limit motor normal cfm set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { dynamics jni . bt rotational limit motor normal cfm set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 1.7%)

<SENTENCE_START> { dynamics jni . bt rotational limit motor normal cfm set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

Original Name get,normal,cfm

get

<SENTENCE_START> { return dynamics jni . bt rotational limit motor normal cfm get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 1.3%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor normal cfm get ( swig c ptr , this ) ; } <SENTENCE_END/>

normal

<SENTENCE_START> { return dynamics jni . bt rotational limit motor normal cfm get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 99.8%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor normal cfm get ( swig c ptr , this ) ; } <SENTENCE_END/>

cfm

<SENTENCE_START> { return dynamics jni . bt rotational limit motor normal cfm get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 84.3%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor normal cfm get ( swig c ptr , this ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return dynamics jni . bt rotational limit motor normal cfm get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 1.5%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor normal cfm get ( swig c ptr , this ) ; } <SENTENCE_END/>

Original Name set,stop,erp

set

<SENTENCE_START> { dynamics jni . bt rotational limit motor stop erp set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 1.2%)

<SENTENCE_START> { dynamics jni . bt rotational limit motor stop erp set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

stop

<SENTENCE_START> { dynamics jni . bt rotational limit motor stop erp set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 99.7%)

<SENTENCE_START> { dynamics jni . bt rotational limit motor stop erp set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

erp

<SENTENCE_START> { dynamics jni . bt rotational limit motor stop erp set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 62.4%)

<SENTENCE_START> { dynamics jni . bt rotational limit motor stop erp set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { dynamics jni . bt rotational limit motor stop erp set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 4.2%)

<SENTENCE_START> { dynamics jni . bt rotational limit motor stop erp set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

Original Name get,stop,erp

get

<SENTENCE_START> { return dynamics jni . bt rotational limit motor stop erp get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 1.3%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor stop erp get ( swig c ptr , this ) ; } <SENTENCE_END/>

stop

<SENTENCE_START> { return dynamics jni . bt rotational limit motor stop erp get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 99.8%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor stop erp get ( swig c ptr , this ) ; } <SENTENCE_END/>

erp

<SENTENCE_START> { return dynamics jni . bt rotational limit motor stop erp get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 81.6%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor stop erp get ( swig c ptr , this ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return dynamics jni . bt rotational limit motor stop erp get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 3.9%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor stop erp get ( swig c ptr , this ) ; } <SENTENCE_END/>

Original Name set,stop,cfm

set

<SENTENCE_START> { dynamics jni . bt rotational limit motor stop cfm set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 1.1%)

<SENTENCE_START> { dynamics jni . bt rotational limit motor stop cfm set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

stop

<SENTENCE_START> { dynamics jni . bt rotational limit motor stop cfm set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 99.7%)

<SENTENCE_START> { dynamics jni . bt rotational limit motor stop cfm set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

cfm

<SENTENCE_START> { dynamics jni . bt rotational limit motor stop cfm set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 64.7%)

<SENTENCE_START> { dynamics jni . bt rotational limit motor stop cfm set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { dynamics jni . bt rotational limit motor stop cfm set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 4.2%)

<SENTENCE_START> { dynamics jni . bt rotational limit motor stop cfm set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

Original Name get,stop,cfm

get

<SENTENCE_START> { return dynamics jni . bt rotational limit motor stop cfm get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 1.2%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor stop cfm get ( swig c ptr , this ) ; } <SENTENCE_END/>

stop

<SENTENCE_START> { return dynamics jni . bt rotational limit motor stop cfm get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 99.7%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor stop cfm get ( swig c ptr , this ) ; } <SENTENCE_END/>

cfm

<SENTENCE_START> { return dynamics jni . bt rotational limit motor stop cfm get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 82.8%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor stop cfm get ( swig c ptr , this ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return dynamics jni . bt rotational limit motor stop cfm get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 3.9%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor stop cfm get ( swig c ptr , this ) ; } <SENTENCE_END/>

Original Name set,bounce

set

<SENTENCE_START> { dynamics jni . bt rotational limit motor bounce set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 1.7%)

<SENTENCE_START> { dynamics jni . bt rotational limit motor bounce set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

bounce

<SENTENCE_START> { dynamics jni . bt rotational limit motor bounce set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 99.0%)

<SENTENCE_START> { dynamics jni . bt rotational limit motor bounce set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { dynamics jni . bt rotational limit motor bounce set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 0.7%)

<SENTENCE_START> { dynamics jni . bt rotational limit motor bounce set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

Original Name get,bounce

get

<SENTENCE_START> { return dynamics jni . bt rotational limit motor bounce get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 1.8%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor bounce get ( swig c ptr , this ) ; } <SENTENCE_END/>

bounce

<SENTENCE_START> { return dynamics jni . bt rotational limit motor bounce get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 98.8%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor bounce get ( swig c ptr , this ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return dynamics jni . bt rotational limit motor bounce get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 0.9%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor bounce get ( swig c ptr , this ) ; } <SENTENCE_END/>

Original Name set,enable,motor

set

<SENTENCE_START> { dynamics jni . bt rotational limit motor enable motor set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 1.9%)

<SENTENCE_START> { dynamics jni . bt rotational limit motor enable motor set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

enable

<SENTENCE_START> { dynamics jni . bt rotational limit motor enable motor set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 99.9%)

<SENTENCE_START> { dynamics jni . bt rotational limit motor enable motor set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

motor

<SENTENCE_START> { dynamics jni . bt rotational limit motor enable motor set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 82.2%)

<SENTENCE_START> { dynamics jni . bt rotational limit motor enable motor set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { dynamics jni . bt rotational limit motor enable motor set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 2.8%)

<SENTENCE_START> { dynamics jni . bt rotational limit motor enable motor set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

Original Name get,enable,motor

get

<SENTENCE_START> { return dynamics jni . bt rotational limit motor enable motor get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 2.0%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor enable motor get ( swig c ptr , this ) ; } <SENTENCE_END/>

enable

<SENTENCE_START> { return dynamics jni . bt rotational limit motor enable motor get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 99.8%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor enable motor get ( swig c ptr , this ) ; } <SENTENCE_END/>

motor

<SENTENCE_START> { return dynamics jni . bt rotational limit motor enable motor get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 92.7%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor enable motor get ( swig c ptr , this ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return dynamics jni . bt rotational limit motor enable motor get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 2.6%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor enable motor get ( swig c ptr , this ) ; } <SENTENCE_END/>

Original Name set,current,limit,error

set

<SENTENCE_START> { dynamics jni . bt rotational limit motor current limit error set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 2.2%)

<SENTENCE_START> { dynamics jni . bt rotational limit motor current limit error set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

current

<SENTENCE_START> { dynamics jni . bt rotational limit motor current limit error set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 99.9%)

<SENTENCE_START> { dynamics jni . bt rotational limit motor current limit error set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

limit

<SENTENCE_START> { dynamics jni . bt rotational limit motor current limit error set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 99.9%)

<SENTENCE_START> { dynamics jni . bt rotational limit motor current limit error set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

error

<SENTENCE_START> { dynamics jni . bt rotational limit motor current limit error set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 67.9%)

<SENTENCE_START> { dynamics jni . bt rotational limit motor current limit error set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { dynamics jni . bt rotational limit motor current limit error set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 6.7%)

<SENTENCE_START> { dynamics jni . bt rotational limit motor current limit error set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

Original Name get,current,limit,error

get

<SENTENCE_START> { return dynamics jni . bt rotational limit motor current limit error get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 2.1%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor current limit error get ( swig c ptr , this ) ; } <SENTENCE_END/>

current

<SENTENCE_START> { return dynamics jni . bt rotational limit motor current limit error get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 99.8%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor current limit error get ( swig c ptr , this ) ; } <SENTENCE_END/>

limit

<SENTENCE_START> { return dynamics jni . bt rotational limit motor current limit error get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 99.9%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor current limit error get ( swig c ptr , this ) ; } <SENTENCE_END/>

error

<SENTENCE_START> { return dynamics jni . bt rotational limit motor current limit error get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 73.6%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor current limit error get ( swig c ptr , this ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return dynamics jni . bt rotational limit motor current limit error get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 7.4%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor current limit error get ( swig c ptr , this ) ; } <SENTENCE_END/>

Original Name set,current,position

set

<SENTENCE_START> { dynamics jni . bt rotational limit motor current position set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 1.1%)

<SENTENCE_START> { dynamics jni . bt rotational limit motor current position set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

current

<SENTENCE_START> { dynamics jni . bt rotational limit motor current position set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 99.7%)

<SENTENCE_START> { dynamics jni . bt rotational limit motor current position set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

position

<SENTENCE_START> { dynamics jni . bt rotational limit motor current position set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 43.1%)

<SENTENCE_START> { dynamics jni . bt rotational limit motor current position set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { dynamics jni . bt rotational limit motor current position set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 1.3%)

<SENTENCE_START> { dynamics jni . bt rotational limit motor current position set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

Original Name get,current,position

get

<SENTENCE_START> { return dynamics jni . bt rotational limit motor current position get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 1.1%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor current position get ( swig c ptr , this ) ; } <SENTENCE_END/>

current

<SENTENCE_START> { return dynamics jni . bt rotational limit motor current position get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 99.7%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor current position get ( swig c ptr , this ) ; } <SENTENCE_END/>

position

<SENTENCE_START> { return dynamics jni . bt rotational limit motor current position get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 66.6%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor current position get ( swig c ptr , this ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return dynamics jni . bt rotational limit motor current position get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 1.5%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor current position get ( swig c ptr , this ) ; } <SENTENCE_END/>

Original Name set,current,limit

set

<SENTENCE_START> { dynamics jni . bt rotational limit motor current limit set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 1.5%)

<SENTENCE_START> { dynamics jni . bt rotational limit motor current limit set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

current

<SENTENCE_START> { dynamics jni . bt rotational limit motor current limit set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 99.8%)

<SENTENCE_START> { dynamics jni . bt rotational limit motor current limit set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

limit

<SENTENCE_START> { dynamics jni . bt rotational limit motor current limit set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 67.5%)

<SENTENCE_START> { dynamics jni . bt rotational limit motor current limit set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { dynamics jni . bt rotational limit motor current limit set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 1.6%)

<SENTENCE_START> { dynamics jni . bt rotational limit motor current limit set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

Original Name get,current,limit

get

<SENTENCE_START> { return dynamics jni . bt rotational limit motor current limit get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 1.6%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor current limit get ( swig c ptr , this ) ; } <SENTENCE_END/>

current

<SENTENCE_START> { return dynamics jni . bt rotational limit motor current limit get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 99.8%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor current limit get ( swig c ptr , this ) ; } <SENTENCE_END/>

limit

<SENTENCE_START> { return dynamics jni . bt rotational limit motor current limit get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 84.2%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor current limit get ( swig c ptr , this ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return dynamics jni . bt rotational limit motor current limit get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 1.6%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor current limit get ( swig c ptr , this ) ; } <SENTENCE_END/>

Original Name set,accumulated,impulse

set

<SENTENCE_START> { dynamics jni . bt rotational limit motor accumulated impulse set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 1.6%)

<SENTENCE_START> { dynamics jni . bt rotational limit motor accumulated impulse set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

accumulated

<SENTENCE_START> { dynamics jni . bt rotational limit motor accumulated impulse set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 99.8%)

<SENTENCE_START> { dynamics jni . bt rotational limit motor accumulated impulse set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

impulse

<SENTENCE_START> { dynamics jni . bt rotational limit motor accumulated impulse set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 98.8%)

<SENTENCE_START> { dynamics jni . bt rotational limit motor accumulated impulse set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { dynamics jni . bt rotational limit motor accumulated impulse set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

(Copy Probability: 3.5%)

<SENTENCE_START> { dynamics jni . bt rotational limit motor accumulated impulse set ( swig c ptr , this , value ) ; } <SENTENCE_END/>

Original Name get,accumulated,impulse

get

<SENTENCE_START> { return dynamics jni . bt rotational limit motor accumulated impulse get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 1.7%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor accumulated impulse get ( swig c ptr , this ) ; } <SENTENCE_END/>

accumulated

<SENTENCE_START> { return dynamics jni . bt rotational limit motor accumulated impulse get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 99.7%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor accumulated impulse get ( swig c ptr , this ) ; } <SENTENCE_END/>

impulse

<SENTENCE_START> { return dynamics jni . bt rotational limit motor accumulated impulse get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 99.5%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor accumulated impulse get ( swig c ptr , this ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return dynamics jni . bt rotational limit motor accumulated impulse get ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 3.6%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor accumulated impulse get ( swig c ptr , this ) ; } <SENTENCE_END/>

Original Name is,limited

is

<SENTENCE_START> { return dynamics jni . bt rotational limit motor is limited ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 5.1%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor is limited ( swig c ptr , this ) ; } <SENTENCE_END/>

limited

<SENTENCE_START> { return dynamics jni . bt rotational limit motor is limited ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 97.9%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor is limited ( swig c ptr , this ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return dynamics jni . bt rotational limit motor is limited ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 0.6%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor is limited ( swig c ptr , this ) ; } <SENTENCE_END/>

Original Name need,apply,torques

need

<SENTENCE_START> { return dynamics jni . bt rotational limit motor need apply torques ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 6.1%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor need apply torques ( swig c ptr , this ) ; } <SENTENCE_END/>

apply

<SENTENCE_START> { return dynamics jni . bt rotational limit motor need apply torques ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 97.3%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor need apply torques ( swig c ptr , this ) ; } <SENTENCE_END/>

torques

<SENTENCE_START> { return dynamics jni . bt rotational limit motor need apply torques ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 16.0%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor need apply torques ( swig c ptr , this ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return dynamics jni . bt rotational limit motor need apply torques ( swig c ptr , this ) ; } <SENTENCE_END/>

(Copy Probability: 1.7%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor need apply torques ( swig c ptr , this ) ; } <SENTENCE_END/>

Original Name test,limit,value

test

<SENTENCE_START> { return dynamics jni . bt rotational limit motor test limit value ( swig c ptr , this , test value ) ; } <SENTENCE_END/>

(Copy Probability: 3.5%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor test limit value ( swig c ptr , this , test value ) ; } <SENTENCE_END/>

limit

<SENTENCE_START> { return dynamics jni . bt rotational limit motor test limit value ( swig c ptr , this , test value ) ; } <SENTENCE_END/>

(Copy Probability: 99.4%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor test limit value ( swig c ptr , this , test value ) ; } <SENTENCE_END/>

value

<SENTENCE_START> { return dynamics jni . bt rotational limit motor test limit value ( swig c ptr , this , test value ) ; } <SENTENCE_END/>

(Copy Probability: 28.7%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor test limit value ( swig c ptr , this , test value ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return dynamics jni . bt rotational limit motor test limit value ( swig c ptr , this , test value ) ; } <SENTENCE_END/>

(Copy Probability: 1.9%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor test limit value ( swig c ptr , this , test value ) ; } <SENTENCE_END/>

Original Name solve,angular,limits

solve

<SENTENCE_START> { return dynamics jni . bt rotational limit motor solve angular limits ( swig c ptr , this , time step , axis , jac diag ab inv , bt rigid body . get c ptr ( body 0 ) , body 0 , bt rigid body . get c ptr ( body 1 ) , body 1 ) ; } <SENTENCE_END/>

(Copy Probability: 20.0%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor solve angular limits ( swig c ptr , this , time step , axis , jac diag ab inv , bt rigid body . get c ptr ( body 0 ) , body 0 , bt rigid body . get c ptr ( body 1 ) , body 1 ) ; } <SENTENCE_END/>

angular

<SENTENCE_START> { return dynamics jni . bt rotational limit motor solve angular limits ( swig c ptr , this , time step , axis , jac diag ab inv , bt rigid body . get c ptr ( body 0 ) , body 0 , bt rigid body . get c ptr ( body 1 ) , body 1 ) ; } <SENTENCE_END/>

(Copy Probability: 99.8%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor solve angular limits ( swig c ptr , this , time step , axis , jac diag ab inv , bt rigid body . get c ptr ( body 0 ) , body 0 , bt rigid body . get c ptr ( body 1 ) , body 1 ) ; } <SENTENCE_END/>

limits

<SENTENCE_START> { return dynamics jni . bt rotational limit motor solve angular limits ( swig c ptr , this , time step , axis , jac diag ab inv , bt rigid body . get c ptr ( body 0 ) , body 0 , bt rigid body . get c ptr ( body 1 ) , body 1 ) ; } <SENTENCE_END/>

(Copy Probability: 94.8%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor solve angular limits ( swig c ptr , this , time step , axis , jac diag ab inv , bt rigid body . get c ptr ( body 0 ) , body 0 , bt rigid body . get c ptr ( body 1 ) , body 1 ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return dynamics jni . bt rotational limit motor solve angular limits ( swig c ptr , this , time step , axis , jac diag ab inv , bt rigid body . get c ptr ( body 0 ) , body 0 , bt rigid body . get c ptr ( body 1 ) , body 1 ) ; } <SENTENCE_END/>

(Copy Probability: 10.3%)

<SENTENCE_START> { return dynamics jni . bt rotational limit motor solve angular limits ( swig c ptr , this , time step , axis , jac diag ab inv , bt rigid body . get c ptr ( body 0 ) , body 0 , bt rigid body . get c ptr ( body 1 ) , body 1 ) ; } <SENTENCE_END/>

Original Name create

create

<SENTENCE_START> { pixmap pixmap 1 = new pixmap ( gdx . files . internal ( "data/bobargb8888-32x32.png" ) ) ; cursor 1 = gdx . graphics . new cursor ( pixmap 1 , 16 , 16 ) ; pixmap pixmap 2 = new pixmap ( 32 , 32 , format . rgba 8888 ) ; pixmap 2 . set color ( color . red ) ; pixmap 2 . fill circle ( 16 , 16 , 8 ) ; cursor 2 = gdx . graphics . new cursor ( pixmap 2 , 16 , 16 ) ; pixmap pixmap 3 = new pixmap ( 32 , 32 , format . rgba 8888 ) ; pixmap 3 . set color ( color . blue ) ; pixmap 3 . fill circle ( 16 , 16 , 8 ) ; cursor 3 = gdx . graphics . new cursor ( pixmap 3 , 16 , 16 ) ; } <SENTENCE_END/>

(Copy Probability: 4.0%)

<SENTENCE_START> { pixmap pixmap 1 = new pixmap ( gdx . files . internal ( "data/bobargb8888-32x32.png" ) ) ; cursor 1 = gdx . graphics . new cursor ( pixmap 1 , 16 , 16 ) ; pixmap pixmap 2 = new pixmap ( 32 , 32 , format . rgba 8888 ) ; pixmap 2 . set color ( color . red ) ; pixmap 2 . fill circle ( 16 , 16 , 8 ) ; cursor 2 = gdx . graphics . new cursor ( pixmap 2 , 16 , 16 ) ; pixmap pixmap 3 = new pixmap ( 32 , 32 , format . rgba 8888 ) ; pixmap 3 . set color ( color . blue ) ; pixmap 3 . fill circle ( 16 , 16 , 8 ) ; cursor 3 = gdx . graphics . new cursor ( pixmap 3 , 16 , 16 ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { pixmap pixmap 1 = new pixmap ( gdx . files . internal ( "data/bobargb8888-32x32.png" ) ) ; cursor 1 = gdx . graphics . new cursor ( pixmap 1 , 16 , 16 ) ; pixmap pixmap 2 = new pixmap ( 32 , 32 , format . rgba 8888 ) ; pixmap 2 . set color ( color . red ) ; pixmap 2 . fill circle ( 16 , 16 , 8 ) ; cursor 2 = gdx . graphics . new cursor ( pixmap 2 , 16 , 16 ) ; pixmap pixmap 3 = new pixmap ( 32 , 32 , format . rgba 8888 ) ; pixmap 3 . set color ( color . blue ) ; pixmap 3 . fill circle ( 16 , 16 , 8 ) ; cursor 3 = gdx . graphics . new cursor ( pixmap 3 , 16 , 16 ) ; } <SENTENCE_END/>

(Copy Probability: 9.2%)

<SENTENCE_START> { pixmap pixmap 1 = new pixmap ( gdx . files . internal ( "data/bobargb8888-32x32.png" ) ) ; cursor 1 = gdx . graphics . new cursor ( pixmap 1 , 16 , 16 ) ; pixmap pixmap 2 = new pixmap ( 32 , 32 , format . rgba 8888 ) ; pixmap 2 . set color ( color . red ) ; pixmap 2 . fill circle ( 16 , 16 , 8 ) ; cursor 2 = gdx . graphics . new cursor ( pixmap 2 , 16 , 16 ) ; pixmap pixmap 3 = new pixmap ( 32 , 32 , format . rgba 8888 ) ; pixmap 3 . set color ( color . blue ) ; pixmap 3 . fill circle ( 16 , 16 , 8 ) ; cursor 3 = gdx . graphics . new cursor ( pixmap 3 , 16 , 16 ) ; } <SENTENCE_END/>

Original Name render

render

<SENTENCE_START> { gdx . gl . gl clear color ( 1 , 1 , 1 , 1 ) ; gdx . gl . gl clear ( gl 20 . gl color buffer bit ) ; if ( gdx . input . is touched ( ) ) { gdx . graphics . set cursor ( cursor 1 ) ; } else { cursor active = ! cursor active ; if ( cursor active ) { gdx . graphics . set cursor ( cursor 2 ) ; } else { gdx . graphics . set cursor ( cursor 3 ) ; } } } <SENTENCE_END/>

(Copy Probability: 3.5%)

<SENTENCE_START> { gdx . gl . gl clear color ( 1 , 1 , 1 , 1 ) ; gdx . gl . gl clear ( gl 20 . gl color buffer bit ) ; if ( gdx . input . is touched ( ) ) { gdx . graphics . set cursor ( cursor 1 ) ; } else { cursor active = ! cursor active ; if ( cursor active ) { gdx . graphics . set cursor ( cursor 2 ) ; } else { gdx . graphics . set cursor ( cursor 3 ) ; } } } <SENTENCE_END/>

%END%

<SENTENCE_START> { gdx . gl . gl clear color ( 1 , 1 , 1 , 1 ) ; gdx . gl . gl clear ( gl 20 . gl color buffer bit ) ; if ( gdx . input . is touched ( ) ) { gdx . graphics . set cursor ( cursor 1 ) ; } else { cursor active = ! cursor active ; if ( cursor active ) { gdx . graphics . set cursor ( cursor 2 ) ; } else { gdx . graphics . set cursor ( cursor 3 ) ; } } } <SENTENCE_END/>

(Copy Probability: 35.1%)

<SENTENCE_START> { gdx . gl . gl clear color ( 1 , 1 , 1 , 1 ) ; gdx . gl . gl clear ( gl 20 . gl color buffer bit ) ; if ( gdx . input . is touched ( ) ) { gdx . graphics . set cursor ( cursor 1 ) ; } else { cursor active = ! cursor active ; if ( cursor active ) { gdx . graphics . set cursor ( cursor 2 ) ; } else { gdx . graphics . set cursor ( cursor 3 ) ; } } } <SENTENCE_END/>

Original Name mix,friction

mix

<SENTENCE_START> { return math utils . sqrt ( friction 1 * friction 2 ) ; } <SENTENCE_END/>

(Copy Probability: 0.8%)

<SENTENCE_START> { return math utils . sqrt ( friction 1 * friction 2 ) ; } <SENTENCE_END/>

friction

<SENTENCE_START> { return math utils . sqrt ( friction 1 * friction 2 ) ; } <SENTENCE_END/>

(Copy Probability: 6.2%)

<SENTENCE_START> { return math utils . sqrt ( friction 1 * friction 2 ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return math utils . sqrt ( friction 1 * friction 2 ) ; } <SENTENCE_END/>

(Copy Probability: 0.9%)

<SENTENCE_START> { return math utils . sqrt ( friction 1 * friction 2 ) ; } <SENTENCE_END/>

Original Name mix,restitution

mix

<SENTENCE_START> { return restitution 1 > restitution 2 ? restitution 1 : restitution 2 ; } <SENTENCE_END/>

(Copy Probability: 0.8%)

<SENTENCE_START> { return restitution 1 > restitution 2 ? restitution 1 : restitution 2 ; } <SENTENCE_END/>

restitution

<SENTENCE_START> { return restitution 1 > restitution 2 ? restitution 1 : restitution 2 ; } <SENTENCE_END/>

(Copy Probability: 80.0%)

<SENTENCE_START> { return restitution 1 > restitution 2 ? restitution 1 : restitution 2 ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return restitution 1 > restitution 2 ? restitution 1 : restitution 2 ; } <SENTENCE_END/>

(Copy Probability: 18.9%)

<SENTENCE_START> { return restitution 1 > restitution 2 ? restitution 1 : restitution 2 ; } <SENTENCE_END/>

Original Name line

line

<SENTENCE_START> { return %SELF% ( start . x , start . y , end . x , end . y ) ; } <SENTENCE_END/>

(Copy Probability: 1.0%)

<SENTENCE_START> { return %SELF% ( start . x , start . y , end . x , end . y ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return %SELF% ( start . x , start . y , end . x , end . y ) ; } <SENTENCE_END/>

(Copy Probability: 0.9%)

<SENTENCE_START> { return %SELF% ( start . x , start . y , end . x , end . y ) ; } <SENTENCE_END/>

Original Name line

line

<SENTENCE_START> { pool . free all ( points ) ; points . clear ( ) ; return %SELF% ( start x , start y , end x , end y , pool , points ) ; } <SENTENCE_END/>

(Copy Probability: 1.6%)

<SENTENCE_START> { pool . free all ( points ) ; points . clear ( ) ; return %SELF% ( start x , start y , end x , end y , pool , points ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { pool . free all ( points ) ; points . clear ( ) ; return %SELF% ( start x , start y , end x , end y , pool , points ) ; } <SENTENCE_END/>

(Copy Probability: 1.1%)

<SENTENCE_START> { pool . free all ( points ) ; points . clear ( ) ; return %SELF% ( start x , start y , end x , end y , pool , points ) ; } <SENTENCE_END/>

Original Name line

line

<SENTENCE_START> { int w = end x - start x ; int h = end y - start y ; int dx 1 = 0 , dy 1 = 0 , dx 2 = 0 , dy 2 = 0 ; if ( w < 0 ) { dx 1 = - 1 ; dx 2 = - 1 ; } else if ( w > 0 ) { dx 1 = 1 ; dx 2 = 1 ; } if ( h < 0 ) dy 1 = - 1 ; else if ( h > 0 ) dy 1 = 1 ; int longest = math . abs ( w ) ; int shortest = math . abs ( h ) ; if ( longest <= shortest ) { longest = math . abs ( h ) ; shortest = math . abs ( w ) ; if ( h < 0 ) dy 2 = - 1 ; else if ( h > 0 ) dy 2 = 1 ; dx 2 = 0 ; } int numerator = longest >> 1 ; for ( int i = 0 ; i <= longest ; i ++ ) { grid point 2 point = pool . obtain ( ) ; point . set ( start x , start y ) ; output . add ( point ) ; numerator += shortest ; if ( numerator > longest ) { numerator -= longest ; start x += dx 1 ; start y += dy 1 ; } else { start x += dx 2 ; start y += dy 2 ; } } return output ; } <SENTENCE_END/>

(Copy Probability: 3.3%)

<SENTENCE_START> { int w = end x - start x ; int h = end y - start y ; int dx 1 = 0 , dy 1 = 0 , dx 2 = 0 , dy 2 = 0 ; if ( w < 0 ) { dx 1 = - 1 ; dx 2 = - 1 ; } else if ( w > 0 ) { dx 1 = 1 ; dx 2 = 1 ; } if ( h < 0 ) dy 1 = - 1 ; else if ( h > 0 ) dy 1 = 1 ; int longest = math . abs ( w ) ; int shortest = math . abs ( h ) ; if ( longest <= shortest ) { longest = math . abs ( h ) ; shortest = math . abs ( w ) ; if ( h < 0 ) dy 2 = - 1 ; else if ( h > 0 ) dy 2 = 1 ; dx 2 = 0 ; } int numerator = longest >> 1 ; for ( int i = 0 ; i <= longest ; i ++ ) { grid point 2 point = pool . obtain ( ) ; point . set ( start x , start y ) ; output . add ( point ) ; numerator += shortest ; if ( numerator > longest ) { numerator -= longest ; start x += dx 1 ; start y += dy 1 ; } else { start x += dx 2 ; start y += dy 2 ; } } return output ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { int w = end x - start x ; int h = end y - start y ; int dx 1 = 0 , dy 1 = 0 , dx 2 = 0 , dy 2 = 0 ; if ( w < 0 ) { dx 1 = - 1 ; dx 2 = - 1 ; } else if ( w > 0 ) { dx 1 = 1 ; dx 2 = 1 ; } if ( h < 0 ) dy 1 = - 1 ; else if ( h > 0 ) dy 1 = 1 ; int longest = math . abs ( w ) ; int shortest = math . abs ( h ) ; if ( longest <= shortest ) { longest = math . abs ( h ) ; shortest = math . abs ( w ) ; if ( h < 0 ) dy 2 = - 1 ; else if ( h > 0 ) dy 2 = 1 ; dx 2 = 0 ; } int numerator = longest >> 1 ; for ( int i = 0 ; i <= longest ; i ++ ) { grid point 2 point = pool . obtain ( ) ; point . set ( start x , start y ) ; output . add ( point ) ; numerator += shortest ; if ( numerator > longest ) { numerator -= longest ; start x += dx 1 ; start y += dy 1 ; } else { start x += dx 2 ; start y += dy 2 ; } } return output ; } <SENTENCE_END/>

(Copy Probability: 5.8%)

<SENTENCE_START> { int w = end x - start x ; int h = end y - start y ; int dx 1 = 0 , dy 1 = 0 , dx 2 = 0 , dy 2 = 0 ; if ( w < 0 ) { dx 1 = - 1 ; dx 2 = - 1 ; } else if ( w > 0 ) { dx 1 = 1 ; dx 2 = 1 ; } if ( h < 0 ) dy 1 = - 1 ; else if ( h > 0 ) dy 1 = 1 ; int longest = math . abs ( w ) ; int shortest = math . abs ( h ) ; if ( longest <= shortest ) { longest = math . abs ( h ) ; shortest = math . abs ( w ) ; if ( h < 0 ) dy 2 = - 1 ; else if ( h > 0 ) dy 2 = 1 ; dx 2 = 0 ; } int numerator = longest >> 1 ; for ( int i = 0 ; i <= longest ; i ++ ) { grid point 2 point = pool . obtain ( ) ; point . set ( start x , start y ) ; output . add ( point ) ; numerator += shortest ; if ( numerator > longest ) { numerator -= longest ; start x += dx 1 ; start y += dy 1 ; } else { start x += dx 2 ; start y += dy 2 ; } } return output ; } <SENTENCE_END/>

Original Name allocate

allocate

<SENTENCE_START> { if ( capacity < 0 ) { throw new illegal argument exception ( ) ; } return buffer factory . new double buffer ( capacity ) ; } <SENTENCE_END/>

(Copy Probability: 1.6%)

<SENTENCE_START> { if ( capacity < 0 ) { throw new illegal argument exception ( ) ; } return buffer factory . new double buffer ( capacity ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { if ( capacity < 0 ) { throw new illegal argument exception ( ) ; } return buffer factory . new double buffer ( capacity ) ; } <SENTENCE_END/>

(Copy Probability: 9.6%)

<SENTENCE_START> { if ( capacity < 0 ) { throw new illegal argument exception ( ) ; } return buffer factory . new double buffer ( capacity ) ; } <SENTENCE_END/>

Original Name wrap

wrap

<SENTENCE_START> { return %SELF% ( array , 0 , array . length ) ; } <SENTENCE_END/>

(Copy Probability: 0.5%)

<SENTENCE_START> { return %SELF% ( array , 0 , array . length ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return %SELF% ( array , 0 , array . length ) ; } <SENTENCE_END/>

(Copy Probability: 0.3%)

<SENTENCE_START> { return %SELF% ( array , 0 , array . length ) ; } <SENTENCE_END/>

Original Name wrap

wrap

<SENTENCE_START> { int length = array . length ; if ( start < 0 || len < 0 || ( long ) start + ( long ) len > length ) { throw new index out of bounds exception ( ) ; } double buffer buf = buffer factory . new double buffer ( array ) ; buf . position = start ; buf . limit = start + len ; return buf ; } <SENTENCE_END/>

(Copy Probability: 2.7%)

<SENTENCE_START> { int length = array . length ; if ( start < 0 || len < 0 || ( long ) start + ( long ) len > length ) { throw new index out of bounds exception ( ) ; } double buffer buf = buffer factory . new double buffer ( array ) ; buf . position = start ; buf . limit = start + len ; return buf ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { int length = array . length ; if ( start < 0 || len < 0 || ( long ) start + ( long ) len > length ) { throw new index out of bounds exception ( ) ; } double buffer buf = buffer factory . new double buffer ( array ) ; buf . position = start ; buf . limit = start + len ; return buf ; } <SENTENCE_END/>

(Copy Probability: 4.8%)

<SENTENCE_START> { int length = array . length ; if ( start < 0 || len < 0 || ( long ) start + ( long ) len > length ) { throw new index out of bounds exception ( ) ; } double buffer buf = buffer factory . new double buffer ( array ) ; buf . position = start ; buf . limit = start + len ; return buf ; } <SENTENCE_END/>

Original Name array

array

<SENTENCE_START> { return protected array ( ) ; } <SENTENCE_END/>

(Copy Probability: 0.3%)

<SENTENCE_START> { return protected array ( ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return protected array ( ) ; } <SENTENCE_END/>

(Copy Probability: 0.2%)

<SENTENCE_START> { return protected array ( ) ; } <SENTENCE_END/>

Original Name array,offset

array

<SENTENCE_START> { return protected array offset ( ) ; } <SENTENCE_END/>

(Copy Probability: 0.4%)

<SENTENCE_START> { return protected array offset ( ) ; } <SENTENCE_END/>

offset

<SENTENCE_START> { return protected array offset ( ) ; } <SENTENCE_END/>

(Copy Probability: 0.4%)

<SENTENCE_START> { return protected array offset ( ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return protected array offset ( ) ; } <SENTENCE_END/>

(Copy Probability: 2.4%)

<SENTENCE_START> { return protected array offset ( ) ; } <SENTENCE_END/>

Original Name compare,to

compare

<SENTENCE_START> { int compare remaining = ( remaining ( ) < other buffer . remaining ( ) ) ? remaining ( ) : other buffer . remaining ( ) ; int this pos = position ; int other pos = other buffer . position ; double this double , other double ; while ( compare remaining > 0 ) { this double = get ( this pos ) ; other double = other buffer . get ( other pos ) ; if ( ( this double != other double ) && ( ( this double == this double ) || ( other double == other double ) ) ) { return this double < other double ? - 1 : 1 ; } this pos ++ ; other pos ++ ; compare remaining -- ; } return remaining ( ) - other buffer . remaining ( ) ; } <SENTENCE_END/>

(Copy Probability: 2.4%)

<SENTENCE_START> { int compare remaining = ( remaining ( ) < other buffer . remaining ( ) ) ? remaining ( ) : other buffer . remaining ( ) ; int this pos = position ; int other pos = other buffer . position ; double this double , other double ; while ( compare remaining > 0 ) { this double = get ( this pos ) ; other double = other buffer . get ( other pos ) ; if ( ( this double != other double ) && ( ( this double == this double ) || ( other double == other double ) ) ) { return this double < other double ? - 1 : 1 ; } this pos ++ ; other pos ++ ; compare remaining -- ; } return remaining ( ) - other buffer . remaining ( ) ; } <SENTENCE_END/>

to

<SENTENCE_START> { int compare remaining = ( remaining ( ) < other buffer . remaining ( ) ) ? remaining ( ) : other buffer . remaining ( ) ; int this pos = position ; int other pos = other buffer . position ; double this double , other double ; while ( compare remaining > 0 ) { this double = get ( this pos ) ; other double = other buffer . get ( other pos ) ; if ( ( this double != other double ) && ( ( this double == this double ) || ( other double == other double ) ) ) { return this double < other double ? - 1 : 1 ; } this pos ++ ; other pos ++ ; compare remaining -- ; } return remaining ( ) - other buffer . remaining ( ) ; } <SENTENCE_END/>

(Copy Probability: 2.8%)

<SENTENCE_START> { int compare remaining = ( remaining ( ) < other buffer . remaining ( ) ) ? remaining ( ) : other buffer . remaining ( ) ; int this pos = position ; int other pos = other buffer . position ; double this double , other double ; while ( compare remaining > 0 ) { this double = get ( this pos ) ; other double = other buffer . get ( other pos ) ; if ( ( this double != other double ) && ( ( this double == this double ) || ( other double == other double ) ) ) { return this double < other double ? - 1 : 1 ; } this pos ++ ; other pos ++ ; compare remaining -- ; } return remaining ( ) - other buffer . remaining ( ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { int compare remaining = ( remaining ( ) < other buffer . remaining ( ) ) ? remaining ( ) : other buffer . remaining ( ) ; int this pos = position ; int other pos = other buffer . position ; double this double , other double ; while ( compare remaining > 0 ) { this double = get ( this pos ) ; other double = other buffer . get ( other pos ) ; if ( ( this double != other double ) && ( ( this double == this double ) || ( other double == other double ) ) ) { return this double < other double ? - 1 : 1 ; } this pos ++ ; other pos ++ ; compare remaining -- ; } return remaining ( ) - other buffer . remaining ( ) ; } <SENTENCE_END/>

(Copy Probability: 2.3%)

<SENTENCE_START> { int compare remaining = ( remaining ( ) < other buffer . remaining ( ) ) ? remaining ( ) : other buffer . remaining ( ) ; int this pos = position ; int other pos = other buffer . position ; double this double , other double ; while ( compare remaining > 0 ) { this double = get ( this pos ) ; other double = other buffer . get ( other pos ) ; if ( ( this double != other double ) && ( ( this double == this double ) || ( other double == other double ) ) ) { return this double < other double ? - 1 : 1 ; } this pos ++ ; other pos ++ ; compare remaining -- ; } return remaining ( ) - other buffer . remaining ( ) ; } <SENTENCE_END/>

Original Name equals

equals

<SENTENCE_START> { if ( ! ( other instanceof double buffer ) ) { return false ; } double buffer other buffer = ( double buffer ) other ; if ( remaining ( ) != other buffer . remaining ( ) ) { return false ; } int my position = position ; int other position = other buffer . position ; boolean equal so far = true ; while ( equal so far && ( my position < limit ) ) { equal so far = get ( my position ++ ) == other buffer . get ( other position ++ ) ; } return equal so far ; } <SENTENCE_END/>

(Copy Probability: 2.7%)

<SENTENCE_START> { if ( ! ( other instanceof double buffer ) ) { return false ; } double buffer other buffer = ( double buffer ) other ; if ( remaining ( ) != other buffer . remaining ( ) ) { return false ; } int my position = position ; int other position = other buffer . position ; boolean equal so far = true ; while ( equal so far && ( my position < limit ) ) { equal so far = get ( my position ++ ) == other buffer . get ( other position ++ ) ; } return equal so far ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { if ( ! ( other instanceof double buffer ) ) { return false ; } double buffer other buffer = ( double buffer ) other ; if ( remaining ( ) != other buffer . remaining ( ) ) { return false ; } int my position = position ; int other position = other buffer . position ; boolean equal so far = true ; while ( equal so far && ( my position < limit ) ) { equal so far = get ( my position ++ ) == other buffer . get ( other position ++ ) ; } return equal so far ; } <SENTENCE_END/>

(Copy Probability: 3.1%)

<SENTENCE_START> { if ( ! ( other instanceof double buffer ) ) { return false ; } double buffer other buffer = ( double buffer ) other ; if ( remaining ( ) != other buffer . remaining ( ) ) { return false ; } int my position = position ; int other position = other buffer . position ; boolean equal so far = true ; while ( equal so far && ( my position < limit ) ) { equal so far = get ( my position ++ ) == other buffer . get ( other position ++ ) ; } return equal so far ; } <SENTENCE_END/>

Original Name get

get

<SENTENCE_START> { return %SELF% ( dest , 0 , dest . length ) ; } <SENTENCE_END/>

(Copy Probability: 0.5%)

<SENTENCE_START> { return %SELF% ( dest , 0 , dest . length ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return %SELF% ( dest , 0 , dest . length ) ; } <SENTENCE_END/>

(Copy Probability: 0.4%)

<SENTENCE_START> { return %SELF% ( dest , 0 , dest . length ) ; } <SENTENCE_END/>

Original Name get

get

<SENTENCE_START> { int length = dest . length ; if ( off < 0 || len < 0 || ( long ) off + ( long ) len > length ) { throw new index out of bounds exception ( ) ; } if ( len > remaining ( ) ) { throw new buffer underflow exception ( ) ; } for ( int i = off ; i < off + len ; i ++ ) { dest [ i ] = %SELF% ( ) ; } return this ; } <SENTENCE_END/>

(Copy Probability: 2.3%)

<SENTENCE_START> { int length = dest . length ; if ( off < 0 || len < 0 || ( long ) off + ( long ) len > length ) { throw new index out of bounds exception ( ) ; } if ( len > remaining ( ) ) { throw new buffer underflow exception ( ) ; } for ( int i = off ; i < off + len ; i ++ ) { dest [ i ] = %SELF% ( ) ; } return this ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { int length = dest . length ; if ( off < 0 || len < 0 || ( long ) off + ( long ) len > length ) { throw new index out of bounds exception ( ) ; } if ( len > remaining ( ) ) { throw new buffer underflow exception ( ) ; } for ( int i = off ; i < off + len ; i ++ ) { dest [ i ] = %SELF% ( ) ; } return this ; } <SENTENCE_END/>

(Copy Probability: 3.6%)

<SENTENCE_START> { int length = dest . length ; if ( off < 0 || len < 0 || ( long ) off + ( long ) len > length ) { throw new index out of bounds exception ( ) ; } if ( len > remaining ( ) ) { throw new buffer underflow exception ( ) ; } for ( int i = off ; i < off + len ; i ++ ) { dest [ i ] = %SELF% ( ) ; } return this ; } <SENTENCE_END/>

Original Name has,array

has

<SENTENCE_START> { return protected has array ( ) ; } <SENTENCE_END/>

(Copy Probability: 0.3%)

<SENTENCE_START> { return protected has array ( ) ; } <SENTENCE_END/>

array

<SENTENCE_START> { return protected has array ( ) ; } <SENTENCE_END/>

(Copy Probability: 0.2%)

<SENTENCE_START> { return protected has array ( ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return protected has array ( ) ; } <SENTENCE_END/>

(Copy Probability: 1.2%)

<SENTENCE_START> { return protected has array ( ) ; } <SENTENCE_END/>

Original Name put

put

<SENTENCE_START> { return %SELF% ( src , 0 , src . length ) ; } <SENTENCE_END/>

(Copy Probability: 0.6%)

<SENTENCE_START> { return %SELF% ( src , 0 , src . length ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return %SELF% ( src , 0 , src . length ) ; } <SENTENCE_END/>

(Copy Probability: 0.2%)

<SENTENCE_START> { return %SELF% ( src , 0 , src . length ) ; } <SENTENCE_END/>

Original Name put

put

<SENTENCE_START> { int length = src . length ; if ( off < 0 || len < 0 || ( long ) off + ( long ) len > length ) { throw new index out of bounds exception ( ) ; } if ( len > remaining ( ) ) { throw new buffer overflow exception ( ) ; } for ( int i = off ; i < off + len ; i ++ ) { %SELF% ( src [ i ] ) ; } return this ; } <SENTENCE_END/>

(Copy Probability: 2.2%)

<SENTENCE_START> { int length = src . length ; if ( off < 0 || len < 0 || ( long ) off + ( long ) len > length ) { throw new index out of bounds exception ( ) ; } if ( len > remaining ( ) ) { throw new buffer overflow exception ( ) ; } for ( int i = off ; i < off + len ; i ++ ) { %SELF% ( src [ i ] ) ; } return this ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { int length = src . length ; if ( off < 0 || len < 0 || ( long ) off + ( long ) len > length ) { throw new index out of bounds exception ( ) ; } if ( len > remaining ( ) ) { throw new buffer overflow exception ( ) ; } for ( int i = off ; i < off + len ; i ++ ) { %SELF% ( src [ i ] ) ; } return this ; } <SENTENCE_END/>

(Copy Probability: 2.4%)

<SENTENCE_START> { int length = src . length ; if ( off < 0 || len < 0 || ( long ) off + ( long ) len > length ) { throw new index out of bounds exception ( ) ; } if ( len > remaining ( ) ) { throw new buffer overflow exception ( ) ; } for ( int i = off ; i < off + len ; i ++ ) { %SELF% ( src [ i ] ) ; } return this ; } <SENTENCE_END/>

Original Name put

put

<SENTENCE_START> { if ( src == this ) { throw new illegal argument exception ( ) ; } if ( src . remaining ( ) > remaining ( ) ) { throw new buffer overflow exception ( ) ; } double [ ] doubles = new double [ src . remaining ( ) ] ; src . get ( doubles ) ; %SELF% ( doubles ) ; return this ; } <SENTENCE_END/>

(Copy Probability: 3.4%)

<SENTENCE_START> { if ( src == this ) { throw new illegal argument exception ( ) ; } if ( src . remaining ( ) > remaining ( ) ) { throw new buffer overflow exception ( ) ; } double [ ] doubles = new double [ src . remaining ( ) ] ; src . get ( doubles ) ; %SELF% ( doubles ) ; return this ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { if ( src == this ) { throw new illegal argument exception ( ) ; } if ( src . remaining ( ) > remaining ( ) ) { throw new buffer overflow exception ( ) ; } double [ ] doubles = new double [ src . remaining ( ) ] ; src . get ( doubles ) ; %SELF% ( doubles ) ; return this ; } <SENTENCE_END/>

(Copy Probability: 5.8%)

<SENTENCE_START> { if ( src == this ) { throw new illegal argument exception ( ) ; } if ( src . remaining ( ) > remaining ( ) ) { throw new buffer overflow exception ( ) ; } double [ ] doubles = new double [ src . remaining ( ) ] ; src . get ( doubles ) ; %SELF% ( doubles ) ; return this ; } <SENTENCE_END/>

Original Name to,string

to

<SENTENCE_START> { string buffer buf = new string buffer ( ) ; buf . append ( get class ( ) . get name ( ) ) ; buf . append ( ", status: capacity=" ) ; buf . append ( capacity ( ) ) ; buf . append ( " position=" ) ; buf . append ( position ( ) ) ; buf . append ( " limit=" ) ; buf . append ( limit ( ) ) ; return buf . %SELF% ( ) ; } <SENTENCE_END/>

(Copy Probability: 2.5%)

<SENTENCE_START> { string buffer buf = new string buffer ( ) ; buf . append ( get class ( ) . get name ( ) ) ; buf . append ( ", status: capacity=" ) ; buf . append ( capacity ( ) ) ; buf . append ( " position=" ) ; buf . append ( position ( ) ) ; buf . append ( " limit=" ) ; buf . append ( limit ( ) ) ; return buf . %SELF% ( ) ; } <SENTENCE_END/>

string

<SENTENCE_START> { string buffer buf = new string buffer ( ) ; buf . append ( get class ( ) . get name ( ) ) ; buf . append ( ", status: capacity=" ) ; buf . append ( capacity ( ) ) ; buf . append ( " position=" ) ; buf . append ( position ( ) ) ; buf . append ( " limit=" ) ; buf . append ( limit ( ) ) ; return buf . %SELF% ( ) ; } <SENTENCE_END/>

(Copy Probability: 5.2%)

<SENTENCE_START> { string buffer buf = new string buffer ( ) ; buf . append ( get class ( ) . get name ( ) ) ; buf . append ( ", status: capacity=" ) ; buf . append ( capacity ( ) ) ; buf . append ( " position=" ) ; buf . append ( position ( ) ) ; buf . append ( " limit=" ) ; buf . append ( limit ( ) ) ; return buf . %SELF% ( ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { string buffer buf = new string buffer ( ) ; buf . append ( get class ( ) . get name ( ) ) ; buf . append ( ", status: capacity=" ) ; buf . append ( capacity ( ) ) ; buf . append ( " position=" ) ; buf . append ( position ( ) ) ; buf . append ( " limit=" ) ; buf . append ( limit ( ) ) ; return buf . %SELF% ( ) ; } <SENTENCE_END/>

(Copy Probability: 2.8%)

<SENTENCE_START> { string buffer buf = new string buffer ( ) ; buf . append ( get class ( ) . get name ( ) ) ; buf . append ( ", status: capacity=" ) ; buf . append ( capacity ( ) ) ; buf . append ( " position=" ) ; buf . append ( position ( ) ) ; buf . append ( " limit=" ) ; buf . append ( limit ( ) ) ; return buf . %SELF% ( ) ; } <SENTENCE_END/>

Original Name get,builder

get

<SENTENCE_START> { for ( final mesh builder mb : builders ) if ( mb . get attributes ( ) . equals ( attributes ) && mb . last index ( ) < short . max value / 2 ) return mb ; final mesh builder result = new mesh builder ( ) ; result . begin ( attributes ) ; builders . add ( result ) ; return result ; } <SENTENCE_END/>

(Copy Probability: 2.6%)

<SENTENCE_START> { for ( final mesh builder mb : builders ) if ( mb . get attributes ( ) . equals ( attributes ) && mb . last index ( ) < short . max value / 2 ) return mb ; final mesh builder result = new mesh builder ( ) ; result . begin ( attributes ) ; builders . add ( result ) ; return result ; } <SENTENCE_END/>

builder

<SENTENCE_START> { for ( final mesh builder mb : builders ) if ( mb . get attributes ( ) . equals ( attributes ) && mb . last index ( ) < short . max value / 2 ) return mb ; final mesh builder result = new mesh builder ( ) ; result . begin ( attributes ) ; builders . add ( result ) ; return result ; } <SENTENCE_END/>

(Copy Probability: 29.3%)

<SENTENCE_START> { for ( final mesh builder mb : builders ) if ( mb . get attributes ( ) . equals ( attributes ) && mb . last index ( ) < short . max value / 2 ) return mb ; final mesh builder result = new mesh builder ( ) ; result . begin ( attributes ) ; builders . add ( result ) ; return result ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { for ( final mesh builder mb : builders ) if ( mb . get attributes ( ) . equals ( attributes ) && mb . last index ( ) < short . max value / 2 ) return mb ; final mesh builder result = new mesh builder ( ) ; result . begin ( attributes ) ; builders . add ( result ) ; return result ; } <SENTENCE_END/>

(Copy Probability: 18.0%)

<SENTENCE_START> { for ( final mesh builder mb : builders ) if ( mb . get attributes ( ) . equals ( attributes ) && mb . last index ( ) < short . max value / 2 ) return mb ; final mesh builder result = new mesh builder ( ) ; result . begin ( attributes ) ; builders . add ( result ) ; return result ; } <SENTENCE_END/>

Original Name begin

begin

<SENTENCE_START> { if ( model != null ) throw new gdx runtime exception ( "Call end() first" ) ; node = null ; model = new model ( ) ; builders . clear ( ) ; } <SENTENCE_END/>

(Copy Probability: 2.1%)

<SENTENCE_START> { if ( model != null ) throw new gdx runtime exception ( "Call end() first" ) ; node = null ; model = new model ( ) ; builders . clear ( ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { if ( model != null ) throw new gdx runtime exception ( "Call end() first" ) ; node = null ; model = new model ( ) ; builders . clear ( ) ; } <SENTENCE_END/>

(Copy Probability: 7.4%)

<SENTENCE_START> { if ( model != null ) throw new gdx runtime exception ( "Call end() first" ) ; node = null ; model = new model ( ) ; builders . clear ( ) ; } <SENTENCE_END/>

Original Name end

end

<SENTENCE_START> { if ( model == null ) throw new gdx runtime exception ( "Call begin() first" ) ; final model result = model ; endnode ( ) ; model = null ; for ( final mesh builder mb : builders ) mb . %SELF% ( ) ; builders . clear ( ) ; rebuild references ( result ) ; return result ; } <SENTENCE_END/>

(Copy Probability: 2.7%)

<SENTENCE_START> { if ( model == null ) throw new gdx runtime exception ( "Call begin() first" ) ; final model result = model ; endnode ( ) ; model = null ; for ( final mesh builder mb : builders ) mb . %SELF% ( ) ; builders . clear ( ) ; rebuild references ( result ) ; return result ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { if ( model == null ) throw new gdx runtime exception ( "Call begin() first" ) ; final model result = model ; endnode ( ) ; model = null ; for ( final mesh builder mb : builders ) mb . %SELF% ( ) ; builders . clear ( ) ; rebuild references ( result ) ; return result ; } <SENTENCE_END/>

(Copy Probability: 10.2%)

<SENTENCE_START> { if ( model == null ) throw new gdx runtime exception ( "Call begin() first" ) ; final model result = model ; endnode ( ) ; model = null ; for ( final mesh builder mb : builders ) mb . %SELF% ( ) ; builders . clear ( ) ; rebuild references ( result ) ; return result ; } <SENTENCE_END/>

Original Name endnode

endnode

<SENTENCE_START> { if ( node != null ) { node = null ; } } <SENTENCE_END/>

(Copy Probability: 0.9%)

<SENTENCE_START> { if ( node != null ) { node = null ; } } <SENTENCE_END/>

%END%

<SENTENCE_START> { if ( node != null ) { node = null ; } } <SENTENCE_END/>

(Copy Probability: 10.6%)

<SENTENCE_START> { if ( node != null ) { node = null ; } } <SENTENCE_END/>

Original Name node

node

<SENTENCE_START> { if ( model == null ) throw new gdx runtime exception ( "Call begin() first" ) ; endnode ( ) ; model . nodes . add ( %SELF% ) ; this . %SELF% = %SELF% ; return %SELF% ; } <SENTENCE_END/>

(Copy Probability: 2.3%)

<SENTENCE_START> { if ( model == null ) throw new gdx runtime exception ( "Call begin() first" ) ; endnode ( ) ; model . nodes . add ( %SELF% ) ; this . %SELF% = %SELF% ; return %SELF% ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { if ( model == null ) throw new gdx runtime exception ( "Call begin() first" ) ; endnode ( ) ; model . nodes . add ( %SELF% ) ; this . %SELF% = %SELF% ; return %SELF% ; } <SENTENCE_END/>

(Copy Probability: 7.1%)

<SENTENCE_START> { if ( model == null ) throw new gdx runtime exception ( "Call begin() first" ) ; endnode ( ) ; model . nodes . add ( %SELF% ) ; this . %SELF% = %SELF% ; return %SELF% ; } <SENTENCE_END/>

Original Name node

node

<SENTENCE_START> { final node %SELF% = new node ( ) ; %SELF% ( %SELF% ) ; %SELF% . id = "node" + model . nodes . size ; return %SELF% ; } <SENTENCE_END/>

(Copy Probability: 1.1%)

<SENTENCE_START> { final node %SELF% = new node ( ) ; %SELF% ( %SELF% ) ; %SELF% . id = "node" + model . nodes . size ; return %SELF% ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { final node %SELF% = new node ( ) ; %SELF% ( %SELF% ) ; %SELF% . id = "node" + model . nodes . size ; return %SELF% ; } <SENTENCE_END/>

(Copy Probability: 1.6%)

<SENTENCE_START> { final node %SELF% = new node ( ) ; %SELF% ( %SELF% ) ; %SELF% . id = "node" + model . nodes . size ; return %SELF% ; } <SENTENCE_END/>

Original Name node

node

<SENTENCE_START> { final node %SELF% = new node ( ) ; %SELF% . id = id ; %SELF% . add children ( model . nodes ) ; %SELF% ( %SELF% ) ; for ( final disposable disposable : model . get managed disposables ( ) ) manage ( disposable ) ; return %SELF% ; } <SENTENCE_END/>

(Copy Probability: 2.2%)

<SENTENCE_START> { final node %SELF% = new node ( ) ; %SELF% . id = id ; %SELF% . add children ( model . nodes ) ; %SELF% ( %SELF% ) ; for ( final disposable disposable : model . get managed disposables ( ) ) manage ( disposable ) ; return %SELF% ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { final node %SELF% = new node ( ) ; %SELF% . id = id ; %SELF% . add children ( model . nodes ) ; %SELF% ( %SELF% ) ; for ( final disposable disposable : model . get managed disposables ( ) ) manage ( disposable ) ; return %SELF% ; } <SENTENCE_END/>

(Copy Probability: 16.8%)

<SENTENCE_START> { final node %SELF% = new node ( ) ; %SELF% . id = id ; %SELF% . add children ( model . nodes ) ; %SELF% ( %SELF% ) ; for ( final disposable disposable : model . get managed disposables ( ) ) manage ( disposable ) ; return %SELF% ; } <SENTENCE_END/>

Original Name manage

manage

<SENTENCE_START> { if ( model == null ) throw new gdx runtime exception ( "Call begin() first" ) ; model . manage disposable ( disposable ) ; } <SENTENCE_END/>

(Copy Probability: 1.8%)

<SENTENCE_START> { if ( model == null ) throw new gdx runtime exception ( "Call begin() first" ) ; model . manage disposable ( disposable ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { if ( model == null ) throw new gdx runtime exception ( "Call begin() first" ) ; model . manage disposable ( disposable ) ; } <SENTENCE_END/>

(Copy Probability: 52.5%)

<SENTENCE_START> { if ( model == null ) throw new gdx runtime exception ( "Call begin() first" ) ; model . manage disposable ( disposable ) ; } <SENTENCE_END/>

Original Name part

part

<SENTENCE_START> { if ( node == null ) node ( ) ; node . parts . add ( new node part ( meshpart , material ) ) ; } <SENTENCE_END/>

(Copy Probability: 3.0%)

<SENTENCE_START> { if ( node == null ) node ( ) ; node . parts . add ( new node part ( meshpart , material ) ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { if ( node == null ) node ( ) ; node . parts . add ( new node part ( meshpart , material ) ) ; } <SENTENCE_END/>

(Copy Probability: 88.5%)

<SENTENCE_START> { if ( node == null ) node ( ) ; node . parts . add ( new node part ( meshpart , material ) ) ; } <SENTENCE_END/>

Original Name part

part

<SENTENCE_START> { final mesh part mesh part = new mesh part ( ) ; mesh part . id = id ; mesh part . primitive type = primitive type ; mesh part . mesh = mesh ; mesh part . offset = offset ; mesh part . size = size ; %SELF% ( mesh part , material ) ; return mesh part ; } <SENTENCE_END/>

(Copy Probability: 2.1%)

<SENTENCE_START> { final mesh part mesh part = new mesh part ( ) ; mesh part . id = id ; mesh part . primitive type = primitive type ; mesh part . mesh = mesh ; mesh part . offset = offset ; mesh part . size = size ; %SELF% ( mesh part , material ) ; return mesh part ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { final mesh part mesh part = new mesh part ( ) ; mesh part . id = id ; mesh part . primitive type = primitive type ; mesh part . mesh = mesh ; mesh part . offset = offset ; mesh part . size = size ; %SELF% ( mesh part , material ) ; return mesh part ; } <SENTENCE_END/>

(Copy Probability: 62.1%)

<SENTENCE_START> { final mesh part mesh part = new mesh part ( ) ; mesh part . id = id ; mesh part . primitive type = primitive type ; mesh part . mesh = mesh ; mesh part . offset = offset ; mesh part . size = size ; %SELF% ( mesh part , material ) ; return mesh part ; } <SENTENCE_END/>

Original Name part

part

<SENTENCE_START> { return %SELF% ( id , mesh , primitive type , 0 , mesh . get num indices ( ) , material ) ; } <SENTENCE_END/>

(Copy Probability: 1.0%)

<SENTENCE_START> { return %SELF% ( id , mesh , primitive type , 0 , mesh . get num indices ( ) , material ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return %SELF% ( id , mesh , primitive type , 0 , mesh . get num indices ( ) , material ) ; } <SENTENCE_END/>

(Copy Probability: 7.4%)

<SENTENCE_START> { return %SELF% ( id , mesh , primitive type , 0 , mesh . get num indices ( ) , material ) ; } <SENTENCE_END/>

Original Name part

part

<SENTENCE_START> { final mesh builder builder = get builder ( attributes ) ; %SELF% ( builder . %SELF% ( id , primitive type ) , material ) ; return builder ; } <SENTENCE_END/>

(Copy Probability: 1.4%)

<SENTENCE_START> { final mesh builder builder = get builder ( attributes ) ; %SELF% ( builder . %SELF% ( id , primitive type ) , material ) ; return builder ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { final mesh builder builder = get builder ( attributes ) ; %SELF% ( builder . %SELF% ( id , primitive type ) , material ) ; return builder ; } <SENTENCE_END/>

(Copy Probability: 65.2%)

<SENTENCE_START> { final mesh builder builder = get builder ( attributes ) ; %SELF% ( builder . %SELF% ( id , primitive type ) , material ) ; return builder ; } <SENTENCE_END/>

Original Name part

part

<SENTENCE_START> { return %SELF% ( id , primitive type , mesh builder . create attributes ( attributes ) , material ) ; } <SENTENCE_END/>

(Copy Probability: 1.1%)

<SENTENCE_START> { return %SELF% ( id , primitive type , mesh builder . create attributes ( attributes ) , material ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return %SELF% ( id , primitive type , mesh builder . create attributes ( attributes ) , material ) ; } <SENTENCE_END/>

(Copy Probability: 2.5%)

<SENTENCE_START> { return %SELF% ( id , primitive type , mesh builder . create attributes ( attributes ) , material ) ; } <SENTENCE_END/>

Original Name create,box

create

<SENTENCE_START> { return %SELF% ( width , height , depth , gl 20 . gl triangles , material , attributes ) ; } <SENTENCE_END/>

(Copy Probability: 1.0%)

<SENTENCE_START> { return %SELF% ( width , height , depth , gl 20 . gl triangles , material , attributes ) ; } <SENTENCE_END/>

box

<SENTENCE_START> { return %SELF% ( width , height , depth , gl 20 . gl triangles , material , attributes ) ; } <SENTENCE_END/>

(Copy Probability: 1.9%)

<SENTENCE_START> { return %SELF% ( width , height , depth , gl 20 . gl triangles , material , attributes ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return %SELF% ( width , height , depth , gl 20 . gl triangles , material , attributes ) ; } <SENTENCE_END/>

(Copy Probability: 0.6%)

<SENTENCE_START> { return %SELF% ( width , height , depth , gl 20 . gl triangles , material , attributes ) ; } <SENTENCE_END/>

Original Name create,box

create

<SENTENCE_START> { begin ( ) ; part ( "box" , primitive type , attributes , material ) . box ( width , height , depth ) ; return end ( ) ; } <SENTENCE_END/>

(Copy Probability: 1.7%)

<SENTENCE_START> { begin ( ) ; part ( "box" , primitive type , attributes , material ) . box ( width , height , depth ) ; return end ( ) ; } <SENTENCE_END/>

box

<SENTENCE_START> { begin ( ) ; part ( "box" , primitive type , attributes , material ) . box ( width , height , depth ) ; return end ( ) ; } <SENTENCE_END/>

(Copy Probability: 3.2%)

<SENTENCE_START> { begin ( ) ; part ( "box" , primitive type , attributes , material ) . box ( width , height , depth ) ; return end ( ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { begin ( ) ; part ( "box" , primitive type , attributes , material ) . box ( width , height , depth ) ; return end ( ) ; } <SENTENCE_END/>

(Copy Probability: 1.1%)

<SENTENCE_START> { begin ( ) ; part ( "box" , primitive type , attributes , material ) . box ( width , height , depth ) ; return end ( ) ; } <SENTENCE_END/>

Original Name create,rect

create

<SENTENCE_START> { return %SELF% ( x 00 , y 00 , z 00 , x 10 , y 10 , z 10 , x 11 , y 11 , z 11 , x 01 , y 01 , z 01 , normal x , normal y , normal z , gl 20 . gl triangles , material , attributes ) ; } <SENTENCE_END/>

(Copy Probability: 2.2%)

<SENTENCE_START> { return %SELF% ( x 00 , y 00 , z 00 , x 10 , y 10 , z 10 , x 11 , y 11 , z 11 , x 01 , y 01 , z 01 , normal x , normal y , normal z , gl 20 . gl triangles , material , attributes ) ; } <SENTENCE_END/>

rect

<SENTENCE_START> { return %SELF% ( x 00 , y 00 , z 00 , x 10 , y 10 , z 10 , x 11 , y 11 , z 11 , x 01 , y 01 , z 01 , normal x , normal y , normal z , gl 20 . gl triangles , material , attributes ) ; } <SENTENCE_END/>

(Copy Probability: 2.0%)

<SENTENCE_START> { return %SELF% ( x 00 , y 00 , z 00 , x 10 , y 10 , z 10 , x 11 , y 11 , z 11 , x 01 , y 01 , z 01 , normal x , normal y , normal z , gl 20 . gl triangles , material , attributes ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return %SELF% ( x 00 , y 00 , z 00 , x 10 , y 10 , z 10 , x 11 , y 11 , z 11 , x 01 , y 01 , z 01 , normal x , normal y , normal z , gl 20 . gl triangles , material , attributes ) ; } <SENTENCE_END/>

(Copy Probability: 1.8%)

<SENTENCE_START> { return %SELF% ( x 00 , y 00 , z 00 , x 10 , y 10 , z 10 , x 11 , y 11 , z 11 , x 01 , y 01 , z 01 , normal x , normal y , normal z , gl 20 . gl triangles , material , attributes ) ; } <SENTENCE_END/>

Original Name create,rect

create

<SENTENCE_START> { begin ( ) ; part ( "rect" , primitive type , attributes , material ) . rect ( x 00 , y 00 , z 00 , x 10 , y 10 , z 10 , x 11 , y 11 , z 11 , x 01 , y 01 , z 01 , normal x , normal y , normal z ) ; return end ( ) ; } <SENTENCE_END/>

(Copy Probability: 2.3%)

<SENTENCE_START> { begin ( ) ; part ( "rect" , primitive type , attributes , material ) . rect ( x 00 , y 00 , z 00 , x 10 , y 10 , z 10 , x 11 , y 11 , z 11 , x 01 , y 01 , z 01 , normal x , normal y , normal z ) ; return end ( ) ; } <SENTENCE_END/>

rect

<SENTENCE_START> { begin ( ) ; part ( "rect" , primitive type , attributes , material ) . rect ( x 00 , y 00 , z 00 , x 10 , y 10 , z 10 , x 11 , y 11 , z 11 , x 01 , y 01 , z 01 , normal x , normal y , normal z ) ; return end ( ) ; } <SENTENCE_END/>

(Copy Probability: 2.3%)

<SENTENCE_START> { begin ( ) ; part ( "rect" , primitive type , attributes , material ) . rect ( x 00 , y 00 , z 00 , x 10 , y 10 , z 10 , x 11 , y 11 , z 11 , x 01 , y 01 , z 01 , normal x , normal y , normal z ) ; return end ( ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { begin ( ) ; part ( "rect" , primitive type , attributes , material ) . rect ( x 00 , y 00 , z 00 , x 10 , y 10 , z 10 , x 11 , y 11 , z 11 , x 01 , y 01 , z 01 , normal x , normal y , normal z ) ; return end ( ) ; } <SENTENCE_END/>

(Copy Probability: 1.5%)

<SENTENCE_START> { begin ( ) ; part ( "rect" , primitive type , attributes , material ) . rect ( x 00 , y 00 , z 00 , x 10 , y 10 , z 10 , x 11 , y 11 , z 11 , x 01 , y 01 , z 01 , normal x , normal y , normal z ) ; return end ( ) ; } <SENTENCE_END/>

Original Name create,cylinder

create

<SENTENCE_START> { return %SELF% ( width , height , depth , divisions , gl 20 . gl triangles , material , attributes ) ; } <SENTENCE_END/>

(Copy Probability: 1.3%)

<SENTENCE_START> { return %SELF% ( width , height , depth , divisions , gl 20 . gl triangles , material , attributes ) ; } <SENTENCE_END/>

cylinder

<SENTENCE_START> { return %SELF% ( width , height , depth , divisions , gl 20 . gl triangles , material , attributes ) ; } <SENTENCE_END/>

(Copy Probability: 2.7%)

<SENTENCE_START> { return %SELF% ( width , height , depth , divisions , gl 20 . gl triangles , material , attributes ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return %SELF% ( width , height , depth , divisions , gl 20 . gl triangles , material , attributes ) ; } <SENTENCE_END/>

(Copy Probability: 0.5%)

<SENTENCE_START> { return %SELF% ( width , height , depth , divisions , gl 20 . gl triangles , material , attributes ) ; } <SENTENCE_END/>

Original Name create,cylinder

create

<SENTENCE_START> { return %SELF% ( width , height , depth , divisions , primitive type , material , attributes , 0 , 360 ) ; } <SENTENCE_END/>

(Copy Probability: 0.9%)

<SENTENCE_START> { return %SELF% ( width , height , depth , divisions , primitive type , material , attributes , 0 , 360 ) ; } <SENTENCE_END/>

cylinder

<SENTENCE_START> { return %SELF% ( width , height , depth , divisions , primitive type , material , attributes , 0 , 360 ) ; } <SENTENCE_END/>

(Copy Probability: 1.1%)

<SENTENCE_START> { return %SELF% ( width , height , depth , divisions , primitive type , material , attributes , 0 , 360 ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return %SELF% ( width , height , depth , divisions , primitive type , material , attributes , 0 , 360 ) ; } <SENTENCE_END/>

(Copy Probability: 0.3%)

<SENTENCE_START> { return %SELF% ( width , height , depth , divisions , primitive type , material , attributes , 0 , 360 ) ; } <SENTENCE_END/>

Original Name create,cylinder

create

<SENTENCE_START> { return %SELF% ( width , height , depth , divisions , gl 20 . gl triangles , material , attributes , angle from , angle to ) ; } <SENTENCE_END/>

(Copy Probability: 1.9%)

<SENTENCE_START> { return %SELF% ( width , height , depth , divisions , gl 20 . gl triangles , material , attributes , angle from , angle to ) ; } <SENTENCE_END/>

cylinder

<SENTENCE_START> { return %SELF% ( width , height , depth , divisions , gl 20 . gl triangles , material , attributes , angle from , angle to ) ; } <SENTENCE_END/>

(Copy Probability: 6.0%)

<SENTENCE_START> { return %SELF% ( width , height , depth , divisions , gl 20 . gl triangles , material , attributes , angle from , angle to ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return %SELF% ( width , height , depth , divisions , gl 20 . gl triangles , material , attributes , angle from , angle to ) ; } <SENTENCE_END/>

(Copy Probability: 1.0%)

<SENTENCE_START> { return %SELF% ( width , height , depth , divisions , gl 20 . gl triangles , material , attributes , angle from , angle to ) ; } <SENTENCE_END/>

Original Name create,cylinder

create

<SENTENCE_START> { begin ( ) ; part ( "cylinder" , primitive type , attributes , material ) . cylinder ( width , height , depth , divisions , angle from , angle to ) ; return end ( ) ; } <SENTENCE_END/>

(Copy Probability: 2.3%)

<SENTENCE_START> { begin ( ) ; part ( "cylinder" , primitive type , attributes , material ) . cylinder ( width , height , depth , divisions , angle from , angle to ) ; return end ( ) ; } <SENTENCE_END/>

cylinder

<SENTENCE_START> { begin ( ) ; part ( "cylinder" , primitive type , attributes , material ) . cylinder ( width , height , depth , divisions , angle from , angle to ) ; return end ( ) ; } <SENTENCE_END/>

(Copy Probability: 4.3%)

<SENTENCE_START> { begin ( ) ; part ( "cylinder" , primitive type , attributes , material ) . cylinder ( width , height , depth , divisions , angle from , angle to ) ; return end ( ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { begin ( ) ; part ( "cylinder" , primitive type , attributes , material ) . cylinder ( width , height , depth , divisions , angle from , angle to ) ; return end ( ) ; } <SENTENCE_END/>

(Copy Probability: 1.2%)

<SENTENCE_START> { begin ( ) ; part ( "cylinder" , primitive type , attributes , material ) . cylinder ( width , height , depth , divisions , angle from , angle to ) ; return end ( ) ; } <SENTENCE_END/>

Original Name create,cone

create

<SENTENCE_START> { return %SELF% ( width , height , depth , divisions , gl 20 . gl triangles , material , attributes ) ; } <SENTENCE_END/>

(Copy Probability: 1.3%)

<SENTENCE_START> { return %SELF% ( width , height , depth , divisions , gl 20 . gl triangles , material , attributes ) ; } <SENTENCE_END/>

cone

<SENTENCE_START> { return %SELF% ( width , height , depth , divisions , gl 20 . gl triangles , material , attributes ) ; } <SENTENCE_END/>

(Copy Probability: 2.7%)

<SENTENCE_START> { return %SELF% ( width , height , depth , divisions , gl 20 . gl triangles , material , attributes ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return %SELF% ( width , height , depth , divisions , gl 20 . gl triangles , material , attributes ) ; } <SENTENCE_END/>

(Copy Probability: 0.5%)

<SENTENCE_START> { return %SELF% ( width , height , depth , divisions , gl 20 . gl triangles , material , attributes ) ; } <SENTENCE_END/>

Original Name create,cone

create

<SENTENCE_START> { return %SELF% ( width , height , depth , divisions , primitive type , material , attributes , 0 , 360 ) ; } <SENTENCE_END/>

(Copy Probability: 0.9%)

<SENTENCE_START> { return %SELF% ( width , height , depth , divisions , primitive type , material , attributes , 0 , 360 ) ; } <SENTENCE_END/>

cone

<SENTENCE_START> { return %SELF% ( width , height , depth , divisions , primitive type , material , attributes , 0 , 360 ) ; } <SENTENCE_END/>

(Copy Probability: 1.1%)

<SENTENCE_START> { return %SELF% ( width , height , depth , divisions , primitive type , material , attributes , 0 , 360 ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return %SELF% ( width , height , depth , divisions , primitive type , material , attributes , 0 , 360 ) ; } <SENTENCE_END/>

(Copy Probability: 0.3%)

<SENTENCE_START> { return %SELF% ( width , height , depth , divisions , primitive type , material , attributes , 0 , 360 ) ; } <SENTENCE_END/>

Original Name create,cone

create

<SENTENCE_START> { return %SELF% ( width , height , depth , divisions , gl 20 . gl triangles , material , attributes , angle from , angle to ) ; } <SENTENCE_END/>

(Copy Probability: 1.9%)

<SENTENCE_START> { return %SELF% ( width , height , depth , divisions , gl 20 . gl triangles , material , attributes , angle from , angle to ) ; } <SENTENCE_END/>

cone

<SENTENCE_START> { return %SELF% ( width , height , depth , divisions , gl 20 . gl triangles , material , attributes , angle from , angle to ) ; } <SENTENCE_END/>

(Copy Probability: 6.0%)

<SENTENCE_START> { return %SELF% ( width , height , depth , divisions , gl 20 . gl triangles , material , attributes , angle from , angle to ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return %SELF% ( width , height , depth , divisions , gl 20 . gl triangles , material , attributes , angle from , angle to ) ; } <SENTENCE_END/>

(Copy Probability: 1.0%)

<SENTENCE_START> { return %SELF% ( width , height , depth , divisions , gl 20 . gl triangles , material , attributes , angle from , angle to ) ; } <SENTENCE_END/>

Original Name create,cone

create

<SENTENCE_START> { begin ( ) ; part ( "cone" , primitive type , attributes , material ) . cone ( width , height , depth , divisions , angle from , angle to ) ; return end ( ) ; } <SENTENCE_END/>

(Copy Probability: 2.3%)

<SENTENCE_START> { begin ( ) ; part ( "cone" , primitive type , attributes , material ) . cone ( width , height , depth , divisions , angle from , angle to ) ; return end ( ) ; } <SENTENCE_END/>

cone

<SENTENCE_START> { begin ( ) ; part ( "cone" , primitive type , attributes , material ) . cone ( width , height , depth , divisions , angle from , angle to ) ; return end ( ) ; } <SENTENCE_END/>

(Copy Probability: 4.6%)

<SENTENCE_START> { begin ( ) ; part ( "cone" , primitive type , attributes , material ) . cone ( width , height , depth , divisions , angle from , angle to ) ; return end ( ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { begin ( ) ; part ( "cone" , primitive type , attributes , material ) . cone ( width , height , depth , divisions , angle from , angle to ) ; return end ( ) ; } <SENTENCE_END/>

(Copy Probability: 1.3%)

<SENTENCE_START> { begin ( ) ; part ( "cone" , primitive type , attributes , material ) . cone ( width , height , depth , divisions , angle from , angle to ) ; return end ( ) ; } <SENTENCE_END/>

Original Name create,sphere

create

<SENTENCE_START> { return %SELF% ( width , height , depth , divisions u , divisions v , gl 20 . gl triangles , material , attributes ) ; } <SENTENCE_END/>

(Copy Probability: 1.3%)

<SENTENCE_START> { return %SELF% ( width , height , depth , divisions u , divisions v , gl 20 . gl triangles , material , attributes ) ; } <SENTENCE_END/>

sphere

<SENTENCE_START> { return %SELF% ( width , height , depth , divisions u , divisions v , gl 20 . gl triangles , material , attributes ) ; } <SENTENCE_END/>

(Copy Probability: 3.0%)

<SENTENCE_START> { return %SELF% ( width , height , depth , divisions u , divisions v , gl 20 . gl triangles , material , attributes ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return %SELF% ( width , height , depth , divisions u , divisions v , gl 20 . gl triangles , material , attributes ) ; } <SENTENCE_END/>

(Copy Probability: 0.8%)

<SENTENCE_START> { return %SELF% ( width , height , depth , divisions u , divisions v , gl 20 . gl triangles , material , attributes ) ; } <SENTENCE_END/>

Original Name create,sphere

create

<SENTENCE_START> { return %SELF% ( width , height , depth , divisions u , divisions v , primitive type , material , attributes , 0 , 360 , 0 , 180 ) ; } <SENTENCE_END/>

(Copy Probability: 1.7%)

<SENTENCE_START> { return %SELF% ( width , height , depth , divisions u , divisions v , primitive type , material , attributes , 0 , 360 , 0 , 180 ) ; } <SENTENCE_END/>

sphere

<SENTENCE_START> { return %SELF% ( width , height , depth , divisions u , divisions v , primitive type , material , attributes , 0 , 360 , 0 , 180 ) ; } <SENTENCE_END/>

(Copy Probability: 2.7%)

<SENTENCE_START> { return %SELF% ( width , height , depth , divisions u , divisions v , primitive type , material , attributes , 0 , 360 , 0 , 180 ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return %SELF% ( width , height , depth , divisions u , divisions v , primitive type , material , attributes , 0 , 360 , 0 , 180 ) ; } <SENTENCE_END/>

(Copy Probability: 0.5%)

<SENTENCE_START> { return %SELF% ( width , height , depth , divisions u , divisions v , primitive type , material , attributes , 0 , 360 , 0 , 180 ) ; } <SENTENCE_END/>

Original Name create,sphere

create

<SENTENCE_START> { return %SELF% ( width , height , depth , divisions u , divisions v , gl 20 . gl triangles , material , attributes , angle u from , angle u to , angle v from , angle v to ) ; } <SENTENCE_END/>

(Copy Probability: 3.7%)

<SENTENCE_START> { return %SELF% ( width , height , depth , divisions u , divisions v , gl 20 . gl triangles , material , attributes , angle u from , angle u to , angle v from , angle v to ) ; } <SENTENCE_END/>

sphere

<SENTENCE_START> { return %SELF% ( width , height , depth , divisions u , divisions v , gl 20 . gl triangles , material , attributes , angle u from , angle u to , angle v from , angle v to ) ; } <SENTENCE_END/>

(Copy Probability: 5.7%)

<SENTENCE_START> { return %SELF% ( width , height , depth , divisions u , divisions v , gl 20 . gl triangles , material , attributes , angle u from , angle u to , angle v from , angle v to ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return %SELF% ( width , height , depth , divisions u , divisions v , gl 20 . gl triangles , material , attributes , angle u from , angle u to , angle v from , angle v to ) ; } <SENTENCE_END/>

(Copy Probability: 1.3%)

<SENTENCE_START> { return %SELF% ( width , height , depth , divisions u , divisions v , gl 20 . gl triangles , material , attributes , angle u from , angle u to , angle v from , angle v to ) ; } <SENTENCE_END/>

Original Name create,sphere

create

<SENTENCE_START> { begin ( ) ; part ( "cylinder" , primitive type , attributes , material ) . sphere ( width , height , depth , divisions u , divisions v , angle u from , angle u to , angle v from , angle v to ) ; return end ( ) ; } <SENTENCE_END/>

(Copy Probability: 3.2%)

<SENTENCE_START> { begin ( ) ; part ( "cylinder" , primitive type , attributes , material ) . sphere ( width , height , depth , divisions u , divisions v , angle u from , angle u to , angle v from , angle v to ) ; return end ( ) ; } <SENTENCE_END/>

sphere

<SENTENCE_START> { begin ( ) ; part ( "cylinder" , primitive type , attributes , material ) . sphere ( width , height , depth , divisions u , divisions v , angle u from , angle u to , angle v from , angle v to ) ; return end ( ) ; } <SENTENCE_END/>

(Copy Probability: 5.6%)

<SENTENCE_START> { begin ( ) ; part ( "cylinder" , primitive type , attributes , material ) . sphere ( width , height , depth , divisions u , divisions v , angle u from , angle u to , angle v from , angle v to ) ; return end ( ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { begin ( ) ; part ( "cylinder" , primitive type , attributes , material ) . sphere ( width , height , depth , divisions u , divisions v , angle u from , angle u to , angle v from , angle v to ) ; return end ( ) ; } <SENTENCE_END/>

(Copy Probability: 1.5%)

<SENTENCE_START> { begin ( ) ; part ( "cylinder" , primitive type , attributes , material ) . sphere ( width , height , depth , divisions u , divisions v , angle u from , angle u to , angle v from , angle v to ) ; return end ( ) ; } <SENTENCE_END/>

Original Name create,capsule

create

<SENTENCE_START> { return %SELF% ( radius , height , divisions , gl 20 . gl triangles , material , attributes ) ; } <SENTENCE_END/>

(Copy Probability: 1.1%)

<SENTENCE_START> { return %SELF% ( radius , height , divisions , gl 20 . gl triangles , material , attributes ) ; } <SENTENCE_END/>

capsule

<SENTENCE_START> { return %SELF% ( radius , height , divisions , gl 20 . gl triangles , material , attributes ) ; } <SENTENCE_END/>

(Copy Probability: 2.3%)

<SENTENCE_START> { return %SELF% ( radius , height , divisions , gl 20 . gl triangles , material , attributes ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return %SELF% ( radius , height , divisions , gl 20 . gl triangles , material , attributes ) ; } <SENTENCE_END/>

(Copy Probability: 0.5%)

<SENTENCE_START> { return %SELF% ( radius , height , divisions , gl 20 . gl triangles , material , attributes ) ; } <SENTENCE_END/>

Original Name create,capsule

create

<SENTENCE_START> { begin ( ) ; part ( "capsule" , primitive type , attributes , material ) . capsule ( radius , height , divisions ) ; return end ( ) ; } <SENTENCE_END/>

(Copy Probability: 3.1%)

<SENTENCE_START> { begin ( ) ; part ( "capsule" , primitive type , attributes , material ) . capsule ( radius , height , divisions ) ; return end ( ) ; } <SENTENCE_END/>

capsule

<SENTENCE_START> { begin ( ) ; part ( "capsule" , primitive type , attributes , material ) . capsule ( radius , height , divisions ) ; return end ( ) ; } <SENTENCE_END/>

(Copy Probability: 20.4%)

<SENTENCE_START> { begin ( ) ; part ( "capsule" , primitive type , attributes , material ) . capsule ( radius , height , divisions ) ; return end ( ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { begin ( ) ; part ( "capsule" , primitive type , attributes , material ) . capsule ( radius , height , divisions ) ; return end ( ) ; } <SENTENCE_END/>

(Copy Probability: 1.3%)

<SENTENCE_START> { begin ( ) ; part ( "capsule" , primitive type , attributes , material ) . capsule ( radius , height , divisions ) ; return end ( ) ; } <SENTENCE_END/>

Original Name rebuild,references

rebuild

<SENTENCE_START> { model . materials . clear ( ) ; model . meshes . clear ( ) ; model . mesh parts . clear ( ) ; for ( final node node : model . nodes ) %SELF% ( model , node ) ; } <SENTENCE_END/>

(Copy Probability: 3.4%)

<SENTENCE_START> { model . materials . clear ( ) ; model . meshes . clear ( ) ; model . mesh parts . clear ( ) ; for ( final node node : model . nodes ) %SELF% ( model , node ) ; } <SENTENCE_END/>

references

<SENTENCE_START> { model . materials . clear ( ) ; model . meshes . clear ( ) ; model . mesh parts . clear ( ) ; for ( final node node : model . nodes ) %SELF% ( model , node ) ; } <SENTENCE_END/>

(Copy Probability: 34.4%)

<SENTENCE_START> { model . materials . clear ( ) ; model . meshes . clear ( ) ; model . mesh parts . clear ( ) ; for ( final node node : model . nodes ) %SELF% ( model , node ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { model . materials . clear ( ) ; model . meshes . clear ( ) ; model . mesh parts . clear ( ) ; for ( final node node : model . nodes ) %SELF% ( model , node ) ; } <SENTENCE_END/>

(Copy Probability: 18.3%)

<SENTENCE_START> { model . materials . clear ( ) ; model . meshes . clear ( ) ; model . mesh parts . clear ( ) ; for ( final node node : model . nodes ) %SELF% ( model , node ) ; } <SENTENCE_END/>

Original Name rebuild,references

rebuild

<SENTENCE_START> { for ( final node part mpm : node . parts ) { if ( ! model . materials . contains ( mpm . material , true ) ) model . materials . add ( mpm . material ) ; if ( ! model . mesh parts . contains ( mpm . mesh part , true ) ) { model . mesh parts . add ( mpm . mesh part ) ; if ( ! model . meshes . contains ( mpm . mesh part . mesh , true ) ) model . meshes . add ( mpm . mesh part . mesh ) ; model . manage disposable ( mpm . mesh part . mesh ) ; } } for ( final node child : node . get children ( ) ) %SELF% ( model , child ) ; } <SENTENCE_END/>

(Copy Probability: 3.4%)

<SENTENCE_START> { for ( final node part mpm : node . parts ) { if ( ! model . materials . contains ( mpm . material , true ) ) model . materials . add ( mpm . material ) ; if ( ! model . mesh parts . contains ( mpm . mesh part , true ) ) { model . mesh parts . add ( mpm . mesh part ) ; if ( ! model . meshes . contains ( mpm . mesh part . mesh , true ) ) model . meshes . add ( mpm . mesh part . mesh ) ; model . manage disposable ( mpm . mesh part . mesh ) ; } } for ( final node child : node . get children ( ) ) %SELF% ( model , child ) ; } <SENTENCE_END/>

references

<SENTENCE_START> { for ( final node part mpm : node . parts ) { if ( ! model . materials . contains ( mpm . material , true ) ) model . materials . add ( mpm . material ) ; if ( ! model . mesh parts . contains ( mpm . mesh part , true ) ) { model . mesh parts . add ( mpm . mesh part ) ; if ( ! model . meshes . contains ( mpm . mesh part . mesh , true ) ) model . meshes . add ( mpm . mesh part . mesh ) ; model . manage disposable ( mpm . mesh part . mesh ) ; } } for ( final node child : node . get children ( ) ) %SELF% ( model , child ) ; } <SENTENCE_END/>

(Copy Probability: 34.2%)

<SENTENCE_START> { for ( final node part mpm : node . parts ) { if ( ! model . materials . contains ( mpm . material , true ) ) model . materials . add ( mpm . material ) ; if ( ! model . mesh parts . contains ( mpm . mesh part , true ) ) { model . mesh parts . add ( mpm . mesh part ) ; if ( ! model . meshes . contains ( mpm . mesh part . mesh , true ) ) model . meshes . add ( mpm . mesh part . mesh ) ; model . manage disposable ( mpm . mesh part . mesh ) ; } } for ( final node child : node . get children ( ) ) %SELF% ( model , child ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { for ( final node part mpm : node . parts ) { if ( ! model . materials . contains ( mpm . material , true ) ) model . materials . add ( mpm . material ) ; if ( ! model . mesh parts . contains ( mpm . mesh part , true ) ) { model . mesh parts . add ( mpm . mesh part ) ; if ( ! model . meshes . contains ( mpm . mesh part . mesh , true ) ) model . meshes . add ( mpm . mesh part . mesh ) ; model . manage disposable ( mpm . mesh part . mesh ) ; } } for ( final node child : node . get children ( ) ) %SELF% ( model , child ) ; } <SENTENCE_END/>

(Copy Probability: 36.9%)

<SENTENCE_START> { for ( final node part mpm : node . parts ) { if ( ! model . materials . contains ( mpm . material , true ) ) model . materials . add ( mpm . material ) ; if ( ! model . mesh parts . contains ( mpm . mesh part , true ) ) { model . mesh parts . add ( mpm . mesh part ) ; if ( ! model . meshes . contains ( mpm . mesh part . mesh , true ) ) model . meshes . add ( mpm . mesh part . mesh ) ; model . manage disposable ( mpm . mesh part . mesh ) ; } } for ( final node child : node . get children ( ) ) %SELF% ( model , child ) ; } <SENTENCE_END/>

Original Name create,xyz,coordinates

create

<SENTENCE_START> { begin ( ) ; mesh part builder part builder ; node node = node ( ) ; part builder = part ( "xyz" , primitive type , attributes , material ) ; part builder . set color ( color . red ) ; part builder . arrow ( 0 , 0 , 0 , axis length , 0 , 0 , cap length , stem thickness , divisions ) ; part builder . set color ( color . green ) ; part builder . arrow ( 0 , 0 , 0 , 0 , axis length , 0 , cap length , stem thickness , divisions ) ; part builder . set color ( color . blue ) ; part builder . arrow ( 0 , 0 , 0 , 0 , 0 , axis length , cap length , stem thickness , divisions ) ; return end ( ) ; } <SENTENCE_END/>

(Copy Probability: 3.4%)

<SENTENCE_START> { begin ( ) ; mesh part builder part builder ; node node = node ( ) ; part builder = part ( "xyz" , primitive type , attributes , material ) ; part builder . set color ( color . red ) ; part builder . arrow ( 0 , 0 , 0 , axis length , 0 , 0 , cap length , stem thickness , divisions ) ; part builder . set color ( color . green ) ; part builder . arrow ( 0 , 0 , 0 , 0 , axis length , 0 , cap length , stem thickness , divisions ) ; part builder . set color ( color . blue ) ; part builder . arrow ( 0 , 0 , 0 , 0 , 0 , axis length , cap length , stem thickness , divisions ) ; return end ( ) ; } <SENTENCE_END/>

xyz

<SENTENCE_START> { begin ( ) ; mesh part builder part builder ; node node = node ( ) ; part builder = part ( "xyz" , primitive type , attributes , material ) ; part builder . set color ( color . red ) ; part builder . arrow ( 0 , 0 , 0 , axis length , 0 , 0 , cap length , stem thickness , divisions ) ; part builder . set color ( color . green ) ; part builder . arrow ( 0 , 0 , 0 , 0 , axis length , 0 , cap length , stem thickness , divisions ) ; part builder . set color ( color . blue ) ; part builder . arrow ( 0 , 0 , 0 , 0 , 0 , axis length , cap length , stem thickness , divisions ) ; return end ( ) ; } <SENTENCE_END/>

(Copy Probability: 29.5%)

<SENTENCE_START> { begin ( ) ; mesh part builder part builder ; node node = node ( ) ; part builder = part ( "xyz" , primitive type , attributes , material ) ; part builder . set color ( color . red ) ; part builder . arrow ( 0 , 0 , 0 , axis length , 0 , 0 , cap length , stem thickness , divisions ) ; part builder . set color ( color . green ) ; part builder . arrow ( 0 , 0 , 0 , 0 , axis length , 0 , cap length , stem thickness , divisions ) ; part builder . set color ( color . blue ) ; part builder . arrow ( 0 , 0 , 0 , 0 , 0 , axis length , cap length , stem thickness , divisions ) ; return end ( ) ; } <SENTENCE_END/>

coordinates

<SENTENCE_START> { begin ( ) ; mesh part builder part builder ; node node = node ( ) ; part builder = part ( "xyz" , primitive type , attributes , material ) ; part builder . set color ( color . red ) ; part builder . arrow ( 0 , 0 , 0 , axis length , 0 , 0 , cap length , stem thickness , divisions ) ; part builder . set color ( color . green ) ; part builder . arrow ( 0 , 0 , 0 , 0 , axis length , 0 , cap length , stem thickness , divisions ) ; part builder . set color ( color . blue ) ; part builder . arrow ( 0 , 0 , 0 , 0 , 0 , axis length , cap length , stem thickness , divisions ) ; return end ( ) ; } <SENTENCE_END/>

(Copy Probability: 7.7%)

<SENTENCE_START> { begin ( ) ; mesh part builder part builder ; node node = node ( ) ; part builder = part ( "xyz" , primitive type , attributes , material ) ; part builder . set color ( color . red ) ; part builder . arrow ( 0 , 0 , 0 , axis length , 0 , 0 , cap length , stem thickness , divisions ) ; part builder . set color ( color . green ) ; part builder . arrow ( 0 , 0 , 0 , 0 , axis length , 0 , cap length , stem thickness , divisions ) ; part builder . set color ( color . blue ) ; part builder . arrow ( 0 , 0 , 0 , 0 , 0 , axis length , cap length , stem thickness , divisions ) ; return end ( ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { begin ( ) ; mesh part builder part builder ; node node = node ( ) ; part builder = part ( "xyz" , primitive type , attributes , material ) ; part builder . set color ( color . red ) ; part builder . arrow ( 0 , 0 , 0 , axis length , 0 , 0 , cap length , stem thickness , divisions ) ; part builder . set color ( color . green ) ; part builder . arrow ( 0 , 0 , 0 , 0 , axis length , 0 , cap length , stem thickness , divisions ) ; part builder . set color ( color . blue ) ; part builder . arrow ( 0 , 0 , 0 , 0 , 0 , axis length , cap length , stem thickness , divisions ) ; return end ( ) ; } <SENTENCE_END/>

(Copy Probability: 2.5%)

<SENTENCE_START> { begin ( ) ; mesh part builder part builder ; node node = node ( ) ; part builder = part ( "xyz" , primitive type , attributes , material ) ; part builder . set color ( color . red ) ; part builder . arrow ( 0 , 0 , 0 , axis length , 0 , 0 , cap length , stem thickness , divisions ) ; part builder . set color ( color . green ) ; part builder . arrow ( 0 , 0 , 0 , 0 , axis length , 0 , cap length , stem thickness , divisions ) ; part builder . set color ( color . blue ) ; part builder . arrow ( 0 , 0 , 0 , 0 , 0 , axis length , cap length , stem thickness , divisions ) ; return end ( ) ; } <SENTENCE_END/>

Original Name create,xyz,coordinates

create

<SENTENCE_START> { return %SELF% ( axis length , 0.1f , 0.1f , 5 , gl 20 . gl triangles , material , attributes ) ; } <SENTENCE_END/>

(Copy Probability: 1.0%)

<SENTENCE_START> { return %SELF% ( axis length , 0.1f , 0.1f , 5 , gl 20 . gl triangles , material , attributes ) ; } <SENTENCE_END/>

xyz

<SENTENCE_START> { return %SELF% ( axis length , 0.1f , 0.1f , 5 , gl 20 . gl triangles , material , attributes ) ; } <SENTENCE_END/>

(Copy Probability: 1.4%)

<SENTENCE_START> { return %SELF% ( axis length , 0.1f , 0.1f , 5 , gl 20 . gl triangles , material , attributes ) ; } <SENTENCE_END/>

coordinates

<SENTENCE_START> { return %SELF% ( axis length , 0.1f , 0.1f , 5 , gl 20 . gl triangles , material , attributes ) ; } <SENTENCE_END/>

(Copy Probability: 1.4%)

<SENTENCE_START> { return %SELF% ( axis length , 0.1f , 0.1f , 5 , gl 20 . gl triangles , material , attributes ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return %SELF% ( axis length , 0.1f , 0.1f , 5 , gl 20 . gl triangles , material , attributes ) ; } <SENTENCE_END/>

(Copy Probability: 2.6%)

<SENTENCE_START> { return %SELF% ( axis length , 0.1f , 0.1f , 5 , gl 20 . gl triangles , material , attributes ) ; } <SENTENCE_END/>

Original Name create,arrow

create

<SENTENCE_START> { begin ( ) ; part ( "arrow" , primitive type , attributes , material ) . arrow ( x 1 , y 1 , z 1 , x 2 , y 2 , z 2 , cap length , stem thickness , divisions ) ; return end ( ) ; } <SENTENCE_END/>

(Copy Probability: 2.5%)

<SENTENCE_START> { begin ( ) ; part ( "arrow" , primitive type , attributes , material ) . arrow ( x 1 , y 1 , z 1 , x 2 , y 2 , z 2 , cap length , stem thickness , divisions ) ; return end ( ) ; } <SENTENCE_END/>

arrow

<SENTENCE_START> { begin ( ) ; part ( "arrow" , primitive type , attributes , material ) . arrow ( x 1 , y 1 , z 1 , x 2 , y 2 , z 2 , cap length , stem thickness , divisions ) ; return end ( ) ; } <SENTENCE_END/>

(Copy Probability: 2.5%)

<SENTENCE_START> { begin ( ) ; part ( "arrow" , primitive type , attributes , material ) . arrow ( x 1 , y 1 , z 1 , x 2 , y 2 , z 2 , cap length , stem thickness , divisions ) ; return end ( ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { begin ( ) ; part ( "arrow" , primitive type , attributes , material ) . arrow ( x 1 , y 1 , z 1 , x 2 , y 2 , z 2 , cap length , stem thickness , divisions ) ; return end ( ) ; } <SENTENCE_END/>

(Copy Probability: 1.9%)

<SENTENCE_START> { begin ( ) ; part ( "arrow" , primitive type , attributes , material ) . arrow ( x 1 , y 1 , z 1 , x 2 , y 2 , z 2 , cap length , stem thickness , divisions ) ; return end ( ) ; } <SENTENCE_END/>

Original Name create,arrow

create

<SENTENCE_START> { return %SELF% ( from . x , from . y , from . z , to . x , to . y , to . z , 0.1f , 0.1f , 5 , gl 20 . gl triangles , material , attributes ) ; } <SENTENCE_END/>

(Copy Probability: 2.0%)

<SENTENCE_START> { return %SELF% ( from . x , from . y , from . z , to . x , to . y , to . z , 0.1f , 0.1f , 5 , gl 20 . gl triangles , material , attributes ) ; } <SENTENCE_END/>

arrow

<SENTENCE_START> { return %SELF% ( from . x , from . y , from . z , to . x , to . y , to . z , 0.1f , 0.1f , 5 , gl 20 . gl triangles , material , attributes ) ; } <SENTENCE_END/>

(Copy Probability: 1.5%)

<SENTENCE_START> { return %SELF% ( from . x , from . y , from . z , to . x , to . y , to . z , 0.1f , 0.1f , 5 , gl 20 . gl triangles , material , attributes ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { return %SELF% ( from . x , from . y , from . z , to . x , to . y , to . z , 0.1f , 0.1f , 5 , gl 20 . gl triangles , material , attributes ) ; } <SENTENCE_END/>

(Copy Probability: 1.4%)

<SENTENCE_START> { return %SELF% ( from . x , from . y , from . z , to . x , to . y , to . z , 0.1f , 0.1f , 5 , gl 20 . gl triangles , material , attributes ) ; } <SENTENCE_END/>

Original Name create,line,grid

create

<SENTENCE_START> { begin ( ) ; mesh part builder part builder = part ( "lines" , gl 20 . gl lines , attributes , material ) ; float xlength = x divisions * x size , zlength = z divisions * z size , hxlength = xlength / 2 , hzlength = zlength / 2 ; float x 1 = - hxlength , y 1 = 0 , z 1 = hzlength , x 2 = - hxlength , y 2 = 0 , z 2 = - hzlength ; for ( int i = 0 ; i <= x divisions ; ++ i ) { part builder . line ( x 1 , y 1 , z 1 , x 2 , y 2 , z 2 ) ; x 1 += x size ; x 2 += x size ; } x 1 = - hxlength ; y 1 = 0 ; z 1 = - hzlength ; x 2 = hxlength ; y 2 = 0 ; z 2 = - hzlength ; for ( int j = 0 ; j <= z divisions ; ++ j ) { part builder . line ( x 1 , y 1 , z 1 , x 2 , y 2 , z 2 ) ; z 1 += z size ; z 2 += z size ; } return end ( ) ; } <SENTENCE_END/>

(Copy Probability: 3.1%)

<SENTENCE_START> { begin ( ) ; mesh part builder part builder = part ( "lines" , gl 20 . gl lines , attributes , material ) ; float xlength = x divisions * x size , zlength = z divisions * z size , hxlength = xlength / 2 , hzlength = zlength / 2 ; float x 1 = - hxlength , y 1 = 0 , z 1 = hzlength , x 2 = - hxlength , y 2 = 0 , z 2 = - hzlength ; for ( int i = 0 ; i <= x divisions ; ++ i ) { part builder . line ( x 1 , y 1 , z 1 , x 2 , y 2 , z 2 ) ; x 1 += x size ; x 2 += x size ; } x 1 = - hxlength ; y 1 = 0 ; z 1 = - hzlength ; x 2 = hxlength ; y 2 = 0 ; z 2 = - hzlength ; for ( int j = 0 ; j <= z divisions ; ++ j ) { part builder . line ( x 1 , y 1 , z 1 , x 2 , y 2 , z 2 ) ; z 1 += z size ; z 2 += z size ; } return end ( ) ; } <SENTENCE_END/>

line

<SENTENCE_START> { begin ( ) ; mesh part builder part builder = part ( "lines" , gl 20 . gl lines , attributes , material ) ; float xlength = x divisions * x size , zlength = z divisions * z size , hxlength = xlength / 2 , hzlength = zlength / 2 ; float x 1 = - hxlength , y 1 = 0 , z 1 = hzlength , x 2 = - hxlength , y 2 = 0 , z 2 = - hzlength ; for ( int i = 0 ; i <= x divisions ; ++ i ) { part builder . line ( x 1 , y 1 , z 1 , x 2 , y 2 , z 2 ) ; x 1 += x size ; x 2 += x size ; } x 1 = - hxlength ; y 1 = 0 ; z 1 = - hzlength ; x 2 = hxlength ; y 2 = 0 ; z 2 = - hzlength ; for ( int j = 0 ; j <= z divisions ; ++ j ) { part builder . line ( x 1 , y 1 , z 1 , x 2 , y 2 , z 2 ) ; z 1 += z size ; z 2 += z size ; } return end ( ) ; } <SENTENCE_END/>

(Copy Probability: 20.4%)

<SENTENCE_START> { begin ( ) ; mesh part builder part builder = part ( "lines" , gl 20 . gl lines , attributes , material ) ; float xlength = x divisions * x size , zlength = z divisions * z size , hxlength = xlength / 2 , hzlength = zlength / 2 ; float x 1 = - hxlength , y 1 = 0 , z 1 = hzlength , x 2 = - hxlength , y 2 = 0 , z 2 = - hzlength ; for ( int i = 0 ; i <= x divisions ; ++ i ) { part builder . line ( x 1 , y 1 , z 1 , x 2 , y 2 , z 2 ) ; x 1 += x size ; x 2 += x size ; } x 1 = - hxlength ; y 1 = 0 ; z 1 = - hzlength ; x 2 = hxlength ; y 2 = 0 ; z 2 = - hzlength ; for ( int j = 0 ; j <= z divisions ; ++ j ) { part builder . line ( x 1 , y 1 , z 1 , x 2 , y 2 , z 2 ) ; z 1 += z size ; z 2 += z size ; } return end ( ) ; } <SENTENCE_END/>

grid

<SENTENCE_START> { begin ( ) ; mesh part builder part builder = part ( "lines" , gl 20 . gl lines , attributes , material ) ; float xlength = x divisions * x size , zlength = z divisions * z size , hxlength = xlength / 2 , hzlength = zlength / 2 ; float x 1 = - hxlength , y 1 = 0 , z 1 = hzlength , x 2 = - hxlength , y 2 = 0 , z 2 = - hzlength ; for ( int i = 0 ; i <= x divisions ; ++ i ) { part builder . line ( x 1 , y 1 , z 1 , x 2 , y 2 , z 2 ) ; x 1 += x size ; x 2 += x size ; } x 1 = - hxlength ; y 1 = 0 ; z 1 = - hzlength ; x 2 = hxlength ; y 2 = 0 ; z 2 = - hzlength ; for ( int j = 0 ; j <= z divisions ; ++ j ) { part builder . line ( x 1 , y 1 , z 1 , x 2 , y 2 , z 2 ) ; z 1 += z size ; z 2 += z size ; } return end ( ) ; } <SENTENCE_END/>

(Copy Probability: 18.8%)

<SENTENCE_START> { begin ( ) ; mesh part builder part builder = part ( "lines" , gl 20 . gl lines , attributes , material ) ; float xlength = x divisions * x size , zlength = z divisions * z size , hxlength = xlength / 2 , hzlength = zlength / 2 ; float x 1 = - hxlength , y 1 = 0 , z 1 = hzlength , x 2 = - hxlength , y 2 = 0 , z 2 = - hzlength ; for ( int i = 0 ; i <= x divisions ; ++ i ) { part builder . line ( x 1 , y 1 , z 1 , x 2 , y 2 , z 2 ) ; x 1 += x size ; x 2 += x size ; } x 1 = - hxlength ; y 1 = 0 ; z 1 = - hzlength ; x 2 = hxlength ; y 2 = 0 ; z 2 = - hzlength ; for ( int j = 0 ; j <= z divisions ; ++ j ) { part builder . line ( x 1 , y 1 , z 1 , x 2 , y 2 , z 2 ) ; z 1 += z size ; z 2 += z size ; } return end ( ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { begin ( ) ; mesh part builder part builder = part ( "lines" , gl 20 . gl lines , attributes , material ) ; float xlength = x divisions * x size , zlength = z divisions * z size , hxlength = xlength / 2 , hzlength = zlength / 2 ; float x 1 = - hxlength , y 1 = 0 , z 1 = hzlength , x 2 = - hxlength , y 2 = 0 , z 2 = - hzlength ; for ( int i = 0 ; i <= x divisions ; ++ i ) { part builder . line ( x 1 , y 1 , z 1 , x 2 , y 2 , z 2 ) ; x 1 += x size ; x 2 += x size ; } x 1 = - hxlength ; y 1 = 0 ; z 1 = - hzlength ; x 2 = hxlength ; y 2 = 0 ; z 2 = - hzlength ; for ( int j = 0 ; j <= z divisions ; ++ j ) { part builder . line ( x 1 , y 1 , z 1 , x 2 , y 2 , z 2 ) ; z 1 += z size ; z 2 += z size ; } return end ( ) ; } <SENTENCE_END/>

(Copy Probability: 6.8%)

<SENTENCE_START> { begin ( ) ; mesh part builder part builder = part ( "lines" , gl 20 . gl lines , attributes , material ) ; float xlength = x divisions * x size , zlength = z divisions * z size , hxlength = xlength / 2 , hzlength = zlength / 2 ; float x 1 = - hxlength , y 1 = 0 , z 1 = hzlength , x 2 = - hxlength , y 2 = 0 , z 2 = - hzlength ; for ( int i = 0 ; i <= x divisions ; ++ i ) { part builder . line ( x 1 , y 1 , z 1 , x 2 , y 2 , z 2 ) ; x 1 += x size ; x 2 += x size ; } x 1 = - hxlength ; y 1 = 0 ; z 1 = - hzlength ; x 2 = hxlength ; y 2 = 0 ; z 2 = - hzlength ; for ( int j = 0 ; j <= z divisions ; ++ j ) { part builder . line ( x 1 , y 1 , z 1 , x 2 , y 2 , z 2 ) ; z 1 += z size ; z 2 += z size ; } return end ( ) ; } <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 broadphase ray callback change ownership ( this , swig c ptr , false ) ; } <SENTENCE_END/>

(Copy Probability: 2.8%)

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

release

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

(Copy Probability: 24.5%)

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

ownership

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

(Copy Probability: 91.8%)

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

%END%

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

(Copy Probability: 10.1%)

<SENTENCE_START> { swig c mem own = false ; collision jni . bt broadphase ray 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 broadphase ray callback change ownership ( this , swig c ptr , true ) ; } <SENTENCE_END/>

(Copy Probability: 3.2%)

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

take

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

(Copy Probability: 24.1%)

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

ownership

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

(Copy Probability: 91.0%)

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

%END%

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

(Copy Probability: 5.1%)

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

Original Name set,ray,direction,inverse

set

<SENTENCE_START> { collision jni . bt broadphase ray callback ray direction inverse set ( swig c ptr , this , bt vector 3 . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

(Copy Probability: 2.9%)

<SENTENCE_START> { collision jni . bt broadphase ray callback ray direction inverse set ( swig c ptr , this , bt vector 3 . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

ray

<SENTENCE_START> { collision jni . bt broadphase ray callback ray direction inverse set ( swig c ptr , this , bt vector 3 . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

(Copy Probability: 99.7%)

<SENTENCE_START> { collision jni . bt broadphase ray callback ray direction inverse set ( swig c ptr , this , bt vector 3 . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

direction

<SENTENCE_START> { collision jni . bt broadphase ray callback ray direction inverse set ( swig c ptr , this , bt vector 3 . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

(Copy Probability: 99.8%)

<SENTENCE_START> { collision jni . bt broadphase ray callback ray direction inverse set ( swig c ptr , this , bt vector 3 . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

inverse

<SENTENCE_START> { collision jni . bt broadphase ray callback ray direction inverse set ( swig c ptr , this , bt vector 3 . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

(Copy Probability: 53.9%)

<SENTENCE_START> { collision jni . bt broadphase ray callback ray direction inverse set ( swig c ptr , this , bt vector 3 . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

%END%

<SENTENCE_START> { collision jni . bt broadphase ray callback ray direction inverse set ( swig c ptr , this , bt vector 3 . get c ptr ( value ) , value ) ; } <SENTENCE_END/>

(Copy Probability: 6.7%)

<SENTENCE_START> { collision jni . bt broadphase ray callback ray direction inverse set ( swig c ptr , this , bt vector 3 . get c ptr ( value ) , value ) ; } <SENTENCE_END/>