26//3/2025
...still learning !!!
public static void techo(String s,Object ... args){
int i=0;
while(i<args.length){
System.out.println(i+" : "+args[i]);
++i;
}
}
public static void main(String[] args) {
//new JHerosOfHistory();
techo("f",0);
techo("f",0,1,3);
techo("f",0,1,2,3,"as much ");
}
(
how much times i need and didnt knew writing code like
)hahhahahhaha
Now solved as
public Vect(E ... oar) {
this();
if(oar!=null){
int i=0,l=oar.length;
super.ensureCapacity(l);
while(i<l){
super.add(oar[i]);
++i;
}
}
}
15/10/21
public class Thr extends Thread{
public volatile boolean keeprun=true;
public boolean paused=true;
public long slwork=1000;
public long slbig=mday;
public void run(){
while(keeprun){
if(paused){
slbig();
}
else{
worksimple();
slwork();
}
}
}
}
Volatile otherwise fucked up !!!!!!!!!!!!!!!!!!!!!!!
when from somewhere i execute
when from somewhere i execute
somethread.keeprun=false;/////will not 'break'.....if not volatile
http://tutorials.jenkov.com/java-concurrency/volatile.html
-------------------------------------------
static double a=1,b=2;
static long counter=0;
static int st=0;//no volatile and only ++counter seems giving
3.145.893.960 about processor speed =3Ghertz but does not break from while(st<5)
3.145.893.960 about processor speed =3Ghertz but does not break from while(st<5)
//static volatile int st=0;//making it volatile will give ~582.862.710 increasements per second
diladi speed / 5,3 !!!!!!
public static void main(String[] args) {
Thread multiplier=new Thread(){
public void run(){
while(st<5){//while(true) instead of local boolean also gives /5 time
++counter;
//a*=b;
//a=System.currentTimeMillis();
}
}
};
long prevc=0;
multiplier.start();
while(true){
++st;
System.out.println(counter+" dif: "+(counter-prevc));
prevc=counter;
Thr.slep(1000);
}
}
--------------------------------------
1/10/2021
System.setProperty("sun.awt.noerasebackground","true");
Note: Using the
static import language feature, you don't have to write Math in front of every math function:
import static java.lang.Math.*;
Math class methods by their simple names. For example:cos(angle);
1\7/18
//
/**/
package jbuilder;
import java.io.Serializable;
public abstract class MinJavaFileMaxKeywordsClassShow extends Object implements Serializable{
strictfp interface classSubfile1{}
protected enum classSubfile2{name;}
final native long bitsFlash()throws IllegalArgumentException;
private transient volatile boolean ProcessorRunFlag=
((this instanceof MinJavaFileMaxKeywordsClassShow));
static void b(){
String ss="!\"%&\\()*+-./:;<=>?[]{|},'";
byte i=0;
short j=0;
int k=0;
float m=0;
double n=0;
assert (k<n) ;
try{
do{
for(;;){
switch(k){
case 0 :
default :
if(true){
synchronized(ss){
continue;
}
}
}
break;
}
}while(false);
}catch(Exception e){
throw new IllegalArgumentException();
}
finally{
}
return;
}
}
"How many pins are there in processor?
Intel 8086 came in DIP and had 40 pins.
Original Pentium came in PGA and had 273 pins.
Opteron 6000 series server CPUs come in LGA and have 1974 pads.
Intel LGA 2011 Xeon / Core i7 chips come in LGA and have 2011 pads.
AMD AM4 CPUs will come in PGA and have 1331 pins.
"
}
class B extends A {
Boolean b;
}
class C extends A{
Character c;
}
class D extends A{
Double d;
}
class E extends A{
}
public class Oktadion {
public static void main(String[] args) {
System.out.println(""+Long.MAX_VALUE);
}
private dion ar[]=new dion[8];
}
class Tetradion {
private dion ar[]=new dion[4];
}
class on{}
class mhon{
private on ar[]=new on[0];
}
class monon{
private on ar[]=new on[1];
}
class dion{
private on ar[]=new on[2];
}
class trion{
private on ar[]=new on[3];
}
class ennon{
private on ar[]=new on[9];
}
///////////////////////////////////////////////////
/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package jan;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.StringTokenizer;
import java.util.Vector;
import javax.swing.JFrame;
import javax.swing.JList;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JScrollPane;
import javax.swing.JSplitPane;
import javax.swing.JTree;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.TreeNode;
/**
*
* @author jimakoskx
*/
public class Dyn extends java.lang.Object implements
TreeNode
{
public static void main(String[] args) {
Dyn test=new Dyn();
test.addObject("V_2");
test.addObject("V_3");
test.addObject("V_4");
test.debugln();
System.out.println("Removed/Founded at: "+test.removeObject("V_35"));
test.debugln();
test.jfrDebug();
}
protected int childCounts=0;
private Vector<Object> v;
public Dyn(){
this(Thread.currentThread());
}
public Dyn(Object userObject){
super();
v=new Vector<Object>();
v.add("null");
v.add(userObject);
}
/**
* clear the programming (after userObject) objects from vector<br>
* one by one<br>
* better if we have v.removeRange(int,int)<br>
* ram overheading by arrays ?...?
*/
public void removeAllObjects(){
//heavy
int i=getSize();
int l=childCounts+2;
while(i>0){
--i;
v.remove(l);
//System.out.println(v.remove(l)+" Removed:OP"+i);
}
//System.out.println("Lefted : "+v.size());
}
/**
* System.out.println("Removed/Founded at: "+test.removeObject("V_35"));
* @param searchIf
* @return the index on virtual vector,if founded or -1
*/
public int removeObject(Object searchIf){
int i=childCounts+2;
int l=v.size();
while(i<l){
if(v.get(i) == searchIf){
v.remove(i);
i-=childCounts;
i-=2;
return i;
}
++i;
}
return -1;
}
/**
* v.remove(childCounts+2+IndexAfterUserObject);
* @param IndexAfterUserObject
*/
public void removeObject(int IndexAfterUserObject){
v.remove(childCounts+2+IndexAfterUserObject);
}
/**
* v.add(afterOnlineCurrentLast);
* @param afterOnlineCurrentLast
*/
public void addObject(Object afterOnlineCurrentLast){
v.add(afterOnlineCurrentLast);
}
/**
*
* @return v.size()-childCounts-2;
*/
public int getSize(){
return v.size()-childCounts-2;
}
/**
*
* @return v.size();
*/
public int getRealSize(){
return v.size();
}
/**
*
* @param timesAfterUserObject
* @return v.get(timesAfterUserObject + childCounts + 2);
*/
public Object getObject(int timesAfterUserObject){
timesAfterUserObject+=2;
timesAfterUserObject+=childCounts;
return v.get(timesAfterUserObject);
}
/**
* v.setElementAt(timesAfterUserObject + childCounts + 2);
* @param newUserObject
* @param timesAfterUserObject
*/
public void setObject(Object newUserObject,int timesAfterUserObject){
timesAfterUserObject+=2;
timesAfterUserObject+=childCounts;
v.setElementAt(newUserObject,timesAfterUserObject);
}
/**
*
* @return the required from overriders class type
*/
public Dyn cr(){return new Dyn();}
/**
*
* @return the UserObject v.get(childCounts+1);
*/
public Object uo(){return v.get(childCounts+1);}
/**
* sets the UserObject <br>
* v.setElementAt(newUserObject, childCounts+1);
* @param newUserObject
*/
public void uo(Object newUserObject){v.setElementAt(newUserObject, childCounts+1);}
/**
*
* @return Parent at (Dyn)v.get(childCounts);
*/
public Dyn par(){return (Dyn)v.get(childCounts);}
/**
* sets the Parent at v.setElementAt(newPar, childCounts);
* @param newPar
*/
public void par(Dyn newPar){v.setElementAt(newPar, childCounts);}
/**
*
* @return Last Child at (Dyn)v.get(childCounts-1);
*/
public Dyn last(){return (Dyn)v.get(childCounts-1);}
/**
* sets the Last at v.setElementAt(newPar, childCounts-1);
* @param newLast
*/
public void last(Dyn newLast){v.setElementAt(newLast, childCounts-1);}
/**
*
* @return number of Children Nodes
*/
public int chc(){return childCounts;}
/**
*
* @param i
* @return children Node on i
*/
public Dyn chi(int i){return (Dyn)v.get(i);}
/**
* replaces child Node on index<br>
* set null the parent of old one
* @param newChild
* @param index
*/
public void chi(Dyn newChild,int index){
Dyn old=(Dyn)v.get(index);
old.par(null);
v.setElementAt(newChild, index);
}
/**
*
* @param newChild
*/
public void addChild(Dyn newChild){
v.insertElementAt(newChild, childCounts);
++childCounts;
newChild.par(this);
}
/**
*
* @param newChild
* @param index
*/
public void insertChild(Dyn newChild,int index){
v.insertElementAt(newChild, index);
++childCounts;
newChild.par(this);
}
/**
*
* @param index
* @return the removed and without parent node
*/
public Dyn removeChild(int index){
Dyn out=(Dyn)v.remove(index);
--childCounts;
out.par(null);//???
return out;
}
/**
* if(v.get(i) == node)
* @param node
* @return index of the removed if founded or -1
*/
public int removeChild(TreeNode node) {
int i=0;
while(i<childCounts){
if(v.get(i) == node){
removeChild(i);
return i;
}
++i;
}
return -1;
}
/**
* Would be better if we could use directlly the Vector array<br>
* v.removeRange(int,int) not allowed here to use..<br>
* removing one by one.(io overloads)
*/
public void removeAllChildren(){
while(childCounts>0){
((Dyn)v.remove(0)).par(null);
--childCounts;
}
}
@Override
public TreeNode getChildAt(int childIndex) {return chi(childIndex);}
@Override
public int getChildCount() {return childCounts;}
@Override
public TreeNode getParent() {return (Dyn)v.get(childCounts);}
@Override
public int getIndex(TreeNode node) {
int i=0;
while(i<childCounts){
if(v.get(i) == node){return i;}
++i;
}
return -1;
}
@Override
public boolean getAllowsChildren() {return true;}
@Override
public boolean isLeaf() {return childCounts==0;}
@Override
public Enumeration children() {
return null;
}
public Dyn crad(Object uo){Dyn out=cr();out.uo(uo);addChild(out);return out;}
public Dyn cradr(Object uo){crad(uo);return this;}
public int cradChildren(Object[] it){
int out=0,i=0;
while(i<it.length){
crad(it[i]);
++i;
++out;
}
return out;
}
public int cradChildren(Vector it){
int out=0,i=0;int l=it.size();
while(i<l){
crad(it.get(i));
++i;
++out;
}
return out;
}
public int cradChildren(DefaultMutableTreeNode it){
int out=0,i=0;int l=it.getChildCount();
while(i<l){
crad(((DefaultMutableTreeNode)it.getChildAt(i)).getUserObject());
++i;
++out;
}
return out;
}
public int cradChildren(Iterator it){
int out=0;
while(it.hasNext()){
crad(it.next());
++out;
}
return out;
}
public int cradChildren(StringTokenizer it){
int out=0;
while(it.hasMoreTokens()){
crad(it.nextToken());
++out;
}
return out;
}
public Dyn cradDeep(Object[] it){
int i=0;Dyn itnode=this;
while(i<it.length){
itnode=itnode.crad(it[i]);
++i;
}
return itnode;
}
public Dyn cradDeep(Vector it){
int i=0;Dyn itnode=this;int l=it.size();
while(i<l){
itnode=itnode.crad(it.get(i));
++i;
}
return itnode;
}
public Dyn cradDeep(DefaultMutableTreeNode it){
int i=0;Dyn itnode=this;int l=it.getChildCount();
while(i<l){
itnode=itnode.crad(((DefaultMutableTreeNode)it.getChildAt(i)).getUserObject());
++i;
}
return itnode;
}
public Dyn cradDeep(Iterator it){
Dyn itnode=this;
while(it.hasNext()){
itnode=itnode.crad(it.next());
}
return itnode;
}
public Dyn cradDeep(StringTokenizer it){
Dyn itnode=this;
while(it.hasMoreTokens()){
itnode=itnode.crad(it.nextToken());
}
return itnode;
}
public static final String classOpen="{";
public static final String classClose="}";
public static final String space=" ";
public void oln(String str){System.out.println(""+str);}
public void olntr(){
olntr(new StringBuffer());
}
public void olntr(StringBuffer carryingReference){
oln(carryingReference+""+uo()+classOpen);
int l=getChildCount();
if(l>0){
int i=0;
carryingReference.append(' ');
while(i<l){chi(i).olntr(carryingReference);++i;}
l=carryingReference.length();
i=l-1;
carryingReference.delete(i, l);
}
oln(classClose);
}
// BINARY SERACH
public int sbdecode(int index){++index;index=-index;return index;}
public int sbencode(int index){index=-index;--index;return index;}
public int sbi(Comparable toCompare){
int lo = 0,hi = getChildCount() - 1,mid; int d;
while (lo <= hi) {mid = lo + (hi - lo) / 2;
d=toCompare.compareTo(chi(mid).uo());
if(d<0){ hi = mid - 1;}
else if (d>0){lo = mid + 1;}
else {return mid;}
}
return sbencode(lo);
}
public Dyn sb(Comparable findOrAdd){
int ioi=sbi(findOrAdd);
if(ioi>-1){return chi(ioi);}
return null;
}
public Dyn sbin(Comparable findOrAdd){
int ioi=sbi(findOrAdd);
if(ioi>-1){
return chi(ioi);
}
else{
Dyn out=cr();
out.uo(findOrAdd);
insertChild(out,sbdecode(ioi));
return out;
}
}
public Dyn sbinr(Comparable findOrAdd){sbin(findOrAdd);return this;}
public int sbinChildren(Iterator it){
int out=0;
while(it.hasNext()){sbin((Comparable)it.next());++out;}
return out;
}
public int sbinChildren(StringTokenizer it){
int out=0;
while(it.hasMoreTokens()){sbin(it.nextToken());++out;}
return out;
}
public int sbinChildren(Object[] it){
int out=0;
while(out<it.length){sbin((Comparable)it[out]);++out;}
return out;
}
public Dyn sbinDeep(Iterator it){
Dyn itnode=this;
while(it.hasNext()){itnode=itnode.sbin((Comparable)it.next());}
return itnode;
}
public Dyn sbinDeep(StringTokenizer it){
Dyn itnode=this;
while(it.hasMoreTokens()){itnode=itnode.sbin(it.nextToken());}
return itnode;
}
public Dyn sbinDeep(Object[] it){
int i=0;
Dyn itnode=this;
while(i<it.length){
itnode=itnode.sbin((Comparable)it[i]);
++i;
}
return itnode;
}
public Dyn sbinDeep(Vector it){
int i=0;
int l=it.size();
Dyn itnode=this;
while(i<l){
itnode=itnode.sbin((Comparable)it.get(i));
++i;
}
return itnode;
}
public JTree jtr(){
return new JTree((TreeNode)this);
}
public JList jl(){
return new JList(v);
}
public JFrame jfr(){
JFrame jfr=new JFrame();
jfr.setTitle(toShortDebugString());
JMenuBar jmb=new JMenuBar();
jfr.setJMenuBar(jmb);
jmb.add(new JMenu("File"));
jfr.setBounds(123,123,323,323);
jfr.getContentPane().add(new JScrollPane(jtr()));
jfr.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
jfr.setVisible(true);
return jfr;
}
public JFrame jfrDebug(){
JFrame jfr=new JFrame();
jfr.setTitle(toShortDebugString());
JMenuBar jmb=new JMenuBar();
jfr.setJMenuBar(jmb);
jmb.add(new JMenu("File"));
jfr.setBounds(123,123,323,323);
JSplitPane jspl=new JSplitPane(JSplitPane.HORIZONTAL_SPLIT,new JScrollPane(jl()),new JScrollPane(jtr()));
jspl.setResizeWeight(0.3);
jfr.getContentPane().add(jspl);
jfr.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
jfr.setVisible(true);
jspl.setDividerLocation(0.3);
return jfr;
}
public String toString(){
return uo().toString();
}
public void debugln(){
System.out.println(""+toDebugString());
}
public String toShortDebugString(){
Object uo=uo();
String out=uo+" - "+uo.getClass().getSimpleName()+"["+getSize()+"{"+chc();
return out;
}
public String toDebugString(){
Object uo=uo();
String out="---------------";
out+="\n"+uo+" - "+uo.getClass();
out+="\nObjects: "+getSize();
out+="\nChildren: "+chc();
out+="\nReal Size: "+getRealSize();
out+="\n";
return out;
}
public String toSuperString(){return super.toString();}
}
//////////////////////////////////////////////////////
/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package jcore;
import java.awt.*;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.StringTokenizer;
import java.util.Vector;
import javax.swing.*;
import javax.swing.tree.DefaultMutableTreeNode;
/**
*
* @author jimakoskx
*/
public class Dmtn extends DefaultMutableTreeNode{
public static void main(String[] args) {
Dmtn t=new Dmtn("root");
t.loadClassPathAndClass(t.getClass());
int i=0;
while(i<0){
t.jfr().setTitle(i+"");
++i;
}
t.jfr().setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
public static final long jimClassId=0;
static int counter=0;
public Dmtn() {
System.out.println(counter+getClass().getName()+"()");
++counter;
}
public Dmtn(int y) {System.out.println("testing temp public Dmtn(int y)");}
public Dmtn(Object userObject) {
super(userObject);
System.out.println(counter+getClass().getName()+"() "+userObject);
++counter;
}
public static final String tag_StringHierarchyAssuptionCancelling="*";
public Dmtn store(String varName,Object varValue){
return this.sbin(varName).sbin(tag_StringHierarchyAssuptionCancelling).crad(varValue);
}
//CASTOR
public String [] args(){return (String[])userObject;}
public int nint(){return ((Integer)userObject).intValue();}
public int nintss(){int out=((Integer)userObject).intValue();userObject=out+1;return out;}
public int nssint(){int out=((Integer)userObject).intValue()+1;userObject=out;return out;}
public Dmtn link(){return (Dmtn)userObject;}
public Comparable comp(){return (Comparable)userObject;}
public Class klass(){return (Class)userObject;}
public Constructor cons(){return (Constructor)userObject;}
public Field fild(){return (Field)userObject;}
public Method meth(){return (Method)userObject;}
public Vector vect(){return (Vector)userObject;}
public StringBuffer sbuf(){return (StringBuffer)userObject;}
//
//general creation as STATIC
public Dmtn cr(){return new Dmtn();}
public BufferedReader criobr(){return new BufferedReader(new InputStreamReader(System.in));}
public Constructor[]crCons(Class cl){return cl.getDeclaredConstructors();}
public Field[]crFilds(Class cl){return cl.getDeclaredFields();}
public Method[]crMeths(Class cl){return cl.getDeclaredMethods();}
//TREE FUNCTIONS
public Dmtn dmtn(int index){return (Dmtn)getChildAt(index);}
public Dmtn crad(Object uo){Dmtn out=cr();out.setUserObject(uo);add(out);return out;}
public Dmtn cradr(Object uo){crad(uo);return this;}
public void oln(String str){System.out.println(""+str);}
public void olntr(){
oln(userObject+"{");
int l=getChildCount();
if(l>0){
int i=0;
while(i<l){dmtn(i).olntr();++i;}
}
oln("}");
}
// BINARY SERACH
public int sbdecode(int index){++index;index=-index;return index;}
public int sbencode(int index){index=-index;--index;return index;}
public int sbi(Comparable toCompare){
int lo = 0,hi = getChildCount() - 1,mid; int d;
while (lo <= hi) {mid = lo + (hi - lo) / 2;
d=toCompare.compareTo(dmtn(mid).comp());
if(d<0){ hi = mid - 1;}
else if (d>0){lo = mid + 1;}
else {return mid;}
}return sbencode(lo);
}
public Dmtn sb(Comparable findOrAdd){
int ioi=sbi(findOrAdd);
if(ioi>-1){return (Dmtn)dmtn(ioi);}
return null;
}
public Dmtn sbin(Comparable findOrAdd){
int ioi=sbi(findOrAdd);
if(ioi>-1){
return (Dmtn)dmtn(ioi);
}
else{
Dmtn out=cr();
out.setUserObject(findOrAdd);
insert(out,sbdecode(ioi));
return out;
}
}
public Dmtn sbinr(Comparable findOrAdd){sbin(findOrAdd);return this;}
public JTree jtr(){JTree out=new JTree(this);return out;}
public JScrollPane jscr(){return new JScrollPane(jtr());}
public JPanel jp(){JPanel out=new JPanel();out.setLayout(new BorderLayout());out.add(BorderLayout.CENTER,jscr());return out;}
private static int jfrxloc=0,jfryloc=0;
public JFrame jfr(){
JFrame out=new JFrame();out.setTitle("def Viewer of : "+this.getClass().getSimpleName()+" "+this);
out.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
Dimension dim=Toolkit.getDefaultToolkit().getScreenSize();
out.setBounds(jfrxloc,jfryloc,dim.width/2,dim.height/2);
out.getContentPane().add(jp());
jfrxloc+=33;if(jfrxloc>dim.width/2){jfrxloc=0;}
jfryloc+=2;if(jfryloc>dim.height/2){jfryloc=0;}
out.setVisible(true);
return out;
}
public Dmtn cll(boolean fixIfNotFound){
if(fixIfNotFound){return sbin("cll");}
else{return sb("cll");}
}
public Dmtn cll(){return sbin("cll");}
public Dmtn loadClassPathAndClass(Class cl){
String cln=cl.getName();
StringTokenizer stok=new StringTokenizer(cln,".");
String tok;
Dmtn it=cll();
while(stok.hasMoreElements()){
tok=stok.nextToken();
it=it.sbin(tok);
}
if(it.getChildCount()>0){
if(it.dmtn(0).userObject instanceof Class){
System.out.println("Already loaded or same exactly package name class ");
return it;
}
}
it.loadClass(cl);
return it;
}
public Dmtn loadClass(Class cl){
Dmtn it=crad(cl);
it.sbin("[assinges]");
it.sbin("cons");
it.sbin("fild");
it.sbin("meth");
it.loadConstructors();
it.loadFilds();
it.loadMethods();
return it;
}
public Dmtn loadedClass(Class cl){
Dmtn it=cll(false);
if(it!=null){
String cln=cl.getName();
StringTokenizer stok=new StringTokenizer(cln,".");
String tok;
while(stok.hasMoreElements()&& it!=null){
tok=stok.nextToken();
it=it.sb(tok);
}
if(it.getChildCount()>0){
if(it.dmtn(0).userObject instanceof Class){
return it;
}
}
}
return null;
}
//refering to as if userobject instance pf class
public Dmtn loadConstructors(){
Constructor ar[]=crCons(klass());
Dmtn quick=sbin("cons");
if(ar.length>0 && quick.getChildCount()==0){
int i=0;
while(i<ar.length){
Class ps[]=ar[i].getParameterTypes();
quick.sbin(ps.length).crad(ar[i]);
++i;
}
quick.pullUpFirstLevel();
}
else{
System.out.println("0 or Already loaded constructors "+klass());
}
return quick;
}
public Dmtn loadFilds(){
Field ar[]=crFilds(klass());
Dmtn quick=sbin("fild");
if(ar.length>0 && quick.getChildCount()==0){
int i=0;
while(i<ar.length){
quick.sbin(ar[i].getName()).crad(ar[i]);
++i;
}
}
else{
System.out.println("0 or Already loaded fields "+klass());
}
return quick;
}
public Dmtn loadMethods(Integer temp){
return null;
}
public Dmtn loadMethods(){
Method ar[]=crMeths(klass());
Dmtn quick=sbin("meth");
if(ar.length>0 && quick.getChildCount()==0){
int i=0;
while(i<ar.length){
Class ps[]=ar[i].getParameterTypes();
quick.sbin(ar[i].getName()).sbin(ps.length).crad(ar[i]);
++i;
}
i=0;
int l=quick.getChildCount();
Dmtn ch;
while(i<l){
ch=quick.dmtn(i);
ch.pullUpFirstLevel();
++i;
}
}
else{
System.out.println("0 or Already loaded methods "+klass());
}
return quick;
}
void pullUpFirstLevel(){
int l=getChildCount();
if(l>0){
Dmtn quickGotheringEggonia=cr();
int i=0;
int j,jl;
Dmtn ch;
while(i<l){
ch=dmtn(i);
jl=ch.getChildCount();
j=0;
while(j<jl){
quickGotheringEggonia.add(ch.dmtn(0));
++j;
}
++i;
}
removeAllChildren();
l=quickGotheringEggonia.getChildCount();
i=0;
while(i<l){
add(quickGotheringEggonia.dmtn(0));
++i;
}
//System.out.println("Eggonia being children:"+i);
}
}
}
