Discrete Autofarm [HIGH WINRATE]

 StrToNumber = ;
 Byte = .byte;
 Char = .char;
 Sub = .sub;
 Subg = .gsub;
 Rep = .rep;
 Concat = .concat;
 Insert = .insert;
 LDExp = .ldexp;
 GetFEnv = getfenv  ()
	 _ENV;
;
 Setmetatable = ;
 PCall = ;
 Select = ;
 Unpack =   .unpack;
 ToNumber = ;
  (ByteString, vmenv, ...)
	 DIP = ;
	 repeatNext;
	ByteString = ((ByteString, ), , (byte)
		 ((byte, ) == ) 
			repeatNext = ((byte, , ));
			 ;
		
			 a = ((byte, ));
			 repeatNext 
				 b = (a, repeatNext);
				repeatNext = ;
				 b;
			
				 a;
			
		
	);
	  (Bit, Start, End)
		 End 
			 Res = (Bit / ( ^ (Start - ))) % ( ^ (((End - ) - (Start - )) + ));
			 Res - (Res % );
		
			 Plc =  ^ (Start - );
			 (((Bit % (Plc + Plc)) >= Plc)  )  ;
		
	
	  ()
		 a = (ByteString, DIP, DIP);
		DIP = DIP + ;
		 a;
	
	  ()
		 a, b = (ByteString, DIP, DIP + );
		DIP = DIP + ;
		 (b * ) + a;
	
	  ()
		 a, b, c, d = (ByteString, DIP, DIP + );
		DIP = DIP + ;
		 (d * ) + (c * ) + (b * ) + a;
	
	  ()
		 Left = ();
		 Right = ();
		 IsNormal = ;
		 Mantissa = ((Right, , ) * ( ^ )) + Left;
		 Exponent = (Right, , );
		 Sign = (((Right, ) == )  -)  ;
		 (Exponent == ) 
			 (Mantissa == ) 
				 Sign * ;
			
				Exponent = ;
				IsNormal = ;
			
		 (Exponent == ) 
			 ((Mantissa == )  (Sign * ( / )))  (Sign * NaN);
		
		 (Sign, Exponent - ) * (IsNormal + (Mantissa / ( ^ )));
	
	  (Len)
		 Str;
		  Len 
			Len = ();
			 (Len == ) 
				 ;
			
		
		Str = (ByteString, DIP, (DIP + Len) - );
		DIP = DIP + Len;
		 FStr = {};
		 Idx = , #Str 
			FStr[Idx] = (((Str, Idx, Idx)));
		
		 (FStr);
	
	 gInt = gBits32;
	  (...)
		 {...}, (, ...);
	
	  ()
		 Instrs = {};
		 Functions = {};
		 Lines = {};
		 Chunk = {Instrs,Functions,,Lines};
		 ConstCount = ();
		 Consts = {};
		 Idx = , ConstCount 
			 Type = ();
			 Cons;
			 (Type == ) 
				Cons = () ~= ;
			 (Type == ) 
				Cons = ();
			 (Type == ) 
				Cons = ();
			
			Consts[Idx] = Cons;
		
		Chunk[] = ();
		 Idx = , () 
			 Descriptor = ();
			 ((Descriptor, , ) == ) 
				 Type = (Descriptor, , );
				 Mask = (Descriptor, , );
				 Inst = {(),(),,};
				 (Type == ) 
					Inst[] = ();
					Inst[] = ();
				 (Type == ) 
					Inst[] = ();
				 (Type == ) 
					Inst[] = () - ( ^ );
				 (Type == ) 
					Inst[] = () - ( ^ );
					Inst[] = ();
				
				 ((Mask, , ) == ) 
					Inst[] = Consts[Inst[]];
				
				 ((Mask, , ) == ) 
					Inst[] = Consts[Inst[]];
				
				 ((Mask, , ) == ) 
					Inst[] = Consts[Inst[]];
				
				Instrs[Idx] = Inst;
			
		
		 Idx = , () 
			Functions[Idx - ] = ();
		
		 Chunk;
	
	  (Chunk, Upvalues, Env)
		 Instr = Chunk[];
		 Proto = Chunk[];
		 Params = Chunk[];
		 (...)
			 Instr = Instr;
			 Proto = Proto;
			 Params = Params;
			 _R = _R;
			 VIP = ;
			 Top = -;
			 Vararg = {};
			 Args = {...};
			 PCount = (, ...) - ;
			 Lupvals = {};
			 Stk = {};
			 Idx = , PCount 
				 (Idx >= Params) 
					Vararg[Idx - Params] = Args[Idx + ];
				
					Stk[Idx] = Args[Idx + ];
				
			
			 Varargsz = (PCount - Params) + ;
			 Inst;
			 ;
			  
				Inst = Instr[VIP];
				 = Inst[];
				 ( <= ) 
					 ( <= ) 
						 ( <= ) 
							 ( <= ) 
								Stk[Inst[]] = Env[Inst[]];
							 ( > ) 
								Stk[Inst[]]();
							
								Stk[Inst[]][Inst[]] = Inst[];
							
						 ( <= ) 
							 ( == ) 
								 A = Inst[];
								 Results, Limit = (Stk[A](Stk[A + ]));
								Top = (Limit + A) - ;
								 Edx = ;
								 Idx = A, Top 
									Edx = Edx + ;
									Stk[Idx] = Results[Edx];
								
							
								Stk[Inst[]] = Inst[];
							
						 ( > ) 
							Stk[Inst[]][Inst[]] = Inst[];
						
							
								;
							
						
					 ( <= ) 
						 ( <= ) 
							 ( > ) 
								 A = Inst[];
								Stk[A](Stk[A + ]);
							
								 A = Inst[];
								 T = Stk[A];
								 Idx = A + , Top 
									(T, Stk[Idx]);
								
							
						 ( > ) 
							 A = Inst[];
							Stk[A] = Stk[A]((Stk, A + , Top));
						
							 A = Inst[];
							 T = Stk[A];
							 Idx = A + , Top 
								(T, Stk[Idx]);
							
						
					 ( <= ) 
						 ( == ) 
							 A = Inst[];
							Stk[A](Stk[A + ]);
						
							 A = Inst[];
							Stk[A]((Stk, A + , Inst[]));
						
					 ( > ) 
						Stk[Inst[]]();
					
						
							;
						
					
				 ( <= ) 
					 ( <= ) 
						 ( <= ) 
							 A = Inst[];
							Stk[A]((Stk, A + , Inst[]));
						 ( > ) 
							Stk[Inst[]] = Inst[];
						
							 A = Inst[];
							Stk[A] = Stk[A]((Stk, A + , Inst[]));
						
					 ( <= ) 
						 ( > ) 
							Stk[Inst[]] = Stk[Inst[]][Inst[]];
						
							 A = Inst[];
							Stk[A] = Stk[A]((Stk, A + , Inst[]));
						
					 ( == ) 
						Stk[Inst[]] = Stk[Inst[]][Inst[]];
					
						Stk[Inst[]] = {};
					
				 ( <= ) 
					 ( <= ) 
						 ( == ) 
							 A = Inst[];
							 Results, Limit = (Stk[A]((Stk, A + , Inst[])));
							Top = (Limit + A) - ;
							 Edx = ;
							 Idx = A, Top 
								Edx = Edx + ;
								Stk[Idx] = Results[Edx];
							
						
							 A = Inst[];
							Stk[A] = Stk[A]((Stk, A + , Top));
						
					 ( > ) 
						 A = Inst[];
						 Results, Limit = (Stk[A]((Stk, A + , Inst[])));
						Top = (Limit + A) - ;
						 Edx = ;
						 Idx = A, Top 
							Edx = Edx + ;
							Stk[Idx] = Results[Edx];
						
					
						Stk[Inst[]] = Env[Inst[]];
					
				 ( <= ) 
					 ( > ) 
						 A = Inst[];
						 B = Stk[Inst[]];
						Stk[A + ] = B;
						Stk[A] = B[Inst[]];
					
						 A = Inst[];
						 B = Stk[Inst[]];
						Stk[A + ] = B;
						Stk[A] = B[Inst[]];
					
				 ( == ) 
					Stk[Inst[]] = {};
				
					 A = Inst[];
					 Results, Limit = (Stk[A](Stk[A + ]));
					Top = (Limit + A) - ;
					 Edx = ;
					 Idx = A, Top 
						Edx = Edx + ;
						Stk[Idx] = Results[Edx];
					
				
				VIP = VIP + ;
			
		;
	
	 ((), {}, vmenv)(...);

(, (), ...);


 link = 
(:(link))()