RiSE4fun Code for HeapDbg

HeapDbg/XSLL

NB7bVq  <a href="http://etslbxtdhwgo.com/">etslbxtdhwgo</a>, [url=http://bimrnptmskqe.com/]bimrnptmskqe[/url], [link=http://uztozlqulfbb.com/]uztozlqulfbb[/link], http://dhmypbnqwlqj.com/

HeapDbg/VQ

using System;

public class Program
	{
		public static object Run()
		{
			Data[] res = new Data[10];

			for(int i = 0; i < 10; ++i)
			{
				if(i % 2 == 0)
					res[i] = new Data();
				else
					res[i] = res[i - 1];
			}

			return res;
		}
	}

	public class Data { public int val;}

HeapDbg/a4

// Create a LinkedList of Data objects
// Self edge on, Next, and label, List
class Data { }
class X: Data { }
class Y: Data { }
class ListNode { public ListNode Next, Prev; public Data Data; }
class Program {
    static object Run() {
        ListNode res = null;
        for (int i = 0; i < 10; ++i) {
            res = new ListNode { Next = res, Data = new X() };
            res.Next.Prev = null
        }
        return new { root = res };
    }
}

HeapDbg/K3

// Create an tree containing nested arrays of speheres
// Everything is nested/unaliased but they all share a special color object
using System;
class Program {
    static object Run() {
        var special = new Color { red = 0, blue = 255, green = 0 };
        var rtn = STreeNode.MakeTree(3, special);
        return new { tree = rtn, scolor = special };
    }
}
class STreeNode {
    public STreeNode left; 
    public STreeNode right; 
    public Sphere[] data;

    public static STreeNode MakeTree(int k, Color c) {
        if (k == 0)
            return null;
        else {
            var sph = new Sphere[5];
            for (int i = 0; i < sph.Length; ++i) {
                var cp = new Point { xpos = k, ypos = k, zpos = k };
                sph[i] = new Sphere { center = cp, color = c, radius = 1F };
            }
            return new STreeNode { left = MakeTree(k - 1, c), right = MakeTree(k - 1, c), data = sph };
        }
    }
}
class Sphere { public Point center; public Color color; public float radius; }
class Color { public int red; public int blue; public int green; }
class Point { public float xpos; public float ypos; public float zpos; }

HeapDbg/Xs

// Creates an array of un-aliased Data objects
class Data { }
class Program {
    static object Run() {
        var res = new Data[10];
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
int j=10;
        return new { root = res };
    }
}

HeapDbg/Xr9

// Create a LinkedList of Data objects
// Self edge on, Next, and label, List
class Data { }
class ListNode { public ListNode Next; public ListNode Tail; public Data Data; }
class Program {
    static object Run() {
        ListNode tail = new ListNode { Next=null, Tail=null, Data=new Data() };
        tail.Tail=tail;
        ListNode res = tail;
        for (int i = 0; i < 10; ++i)
            res = new ListNode { Next = res, Tail = tail, Data = new Data() };
        return new { root = res };
    }
}

HeapDbg/XR

// Creates an array of un-aliased Data objects
class Data { }
class Program {
    static object Run() {
        var res = new object[10];
        for (int i = 0; i < res.Length; ++i)
            res[i] = i % 2 == 0 ? null : new Data();
        return new { root = res };
    }
}

HeapDbg/0

using System;

public class Result { public STreeNode tree; public Color scolor;}

	public class Program
	{
		public static object Run()
		{
			Color special = new Color { red = 0, blue = 255, green = 0 };
			STreeNode rtn = STreeNode.MakeTree(3, special);

			return new Result { tree = rtn, scolor = special };
		}
	}
	public class STreeNode
	{
		public STreeNode left; public STreeNode right; public Sphere[] data;

		public static STreeNode MakeTree(int k, Color c)
		{
			if(k == 0)
				return null;
			else
			{
				Sphere[] sph = new Sphere[5];
				for(int i = 0; i < 5; ++i)
					sph[i] = new Sphere { Center = new Point { xpos = k, ypos = k, zpos = k }, Color = c, radius = 1F };
			
				return new STreeNode { left = MakeTree(k - 1, c), right = MakeTree(k - 1, c), data = sph };
			}
		}
	}

	public class Sphere { public Point center; public Color color; public float radius; }
	public class Color { public int red; public int blue; public int green; }
	public class Point { public float xpos; public float ypos; public float zpos; }

HeapDbg/LNz

// Creates a Tree of Data objects
class Data { }
class TreeNode {
    public TreeNode Left;  public TreeNode Right; 
    public Data Data;
    public static TreeNode MakeTree(int k) {
        if (k <= 0)
            return null;
        else
            return new TreeNode { 
                Left = MakeTree(k - 1), 
                Right = MakeTree(k - 1), 
                Data = new Data() 
            };
    }
}
class Program {
    static object Run() {
        return new { root = TreeNode.MakeTree(3) };
    }time
}

HeapDbg/Z6

public class maxarray
{
  int LENGTH = 100;
  int max;
  int[] vec = new int[LENGTH];

  /*@ 
  @ ensures 0 <= max < LENGTH &&
  @        (\forall int a; 0 <= a < LENGTH ==> vec[a] <= vec[max]);
  @*/
  private void maxarray1() {
     int i = 1;
     max = 0;
      
  /*@ loop_invariant 
    @    1 <= i <= LENGTH && 0 <= max < i && 
    @    (\forall int a; 0 <= a < i ==> vec[a] <= vec[max]);
    @*/
  while (i < LENGTH) {
    if (vec[i] > vec[max]) { max = i; }
        i = i +1;
    }
  }
}

HeapDbg/xpY

// Create a LinkedList of Data objects
// Self edge on, Next, and label, List
class Data { }
class X: Data { }
class Y: Data { }
class ListNode { public ListNode Next; public Data Data; }
class Program {
    static object Run() {
        ListNode res = null;
        for (int i = 0; i < 10; ++i) {
            res = new ListNode { Next = res, Data = new X() };
            res = new ListNode { Next = res, Data = new Y() };
        }
        return new { root = res };
    }
}

HeapDbg/X5

// Creates a Tree of Data objects
class Data { }
class TreeNode {
    public TreeNode Left;  public TreeNode Right; 
    public Data Data;
    public static TreeNode MakeTree(int k) {
        if (k <= 0)
            return null;
        else
            return new TreeNode { 
                Left = MakeTree(k - 1), 
                Right = MakeTree(k - 1), 
                Data = new Data() 
            };
    }
}
class Program {
    static object Run() {
        return new { root = TreeNode.MakeTree(3) };
    }
}

HeapDbg/j8

using System;

public class Program
	{
		public static object Run()
		{
			Dictionary<int, Sphere[]> nestedDict = new Dictionary<int, Sphere[]>();

			for(int i = 0; i < 10; ++i)
			{
				Sphere[] spheres = new Sphere[10];
				Color rgb = new Color { red = 0, blue = 255, green = 0 };

				for(int j = 0; j < 10; ++j)
				{
					Point ctr = new Point { xpos = i, ypos = i + j, zpos = i - j };
					spheres[i] = new Sphere { center = ctr, color = rgb, radius = 3.0F };
				}

				nestedDict.Add(i, spheres);
			}

			return nestedDict;
		}
	}

	public class Sphere { public Point center; public Color color; public float radius; }
	public class Color { public int red; public int blue; public int green; }
	public class Point { public float xpos; public float ypos; public float zpos; }

HeapDbg/bGT

/*  -*- Last-Edit:  Fri Jan 29 11:13:27 2006 by Tarak S. Goradia; -*- */
/* $Log: tcas_v23_523.c,v $
 * Revision 1.2  2006/03/12  19:29:50  foster
 * Correct logic bug which didn't allow output of 2 - hf
 * */
//#include <assert.h>

#define OLEV       600		/* in feet/minute */
#define MAXALTDIFF 600		/* max altitude difference in feet */
#define MINSEP     300          /* min separation in feet */
#define NOZCROSS   100		/* in feet */
				/* variables */

typedef int bool;

int Cur_Vertical_Sep;
bool High_Confidence;
bool Two_of_Three_Reports_Valid;

int Own_Tracked_Alt;
int Own_Tracked_Alt_Rate;
int Other_Tracked_Alt;

int Alt_Layer_Value;		/* 0, 1, 2, 3 */
int Positive_RA_Alt_Thresh[4];

int Up_Separation;
int Down_Separation;

				/* state variables */
int Other_RAC;			/* NO_INTENT, DO_NOT_CLIMB, DO_NOT_DESCEND */
#define NO_INTENT 0
#define DO_NOT_CLIMB 1
#define DO_NOT_DESCEND 2

int Other_Capability;		/* TCAS_TA, OTHER */
#define TCAS_TA 1
#define OTHER 2

int Climb_Inhibit;		/* true/false */

#define UNRESOLVED 0
#define UPWARD_RA 1
#define DOWNWARD_RA 2

int  ALIM();
int  Inhibit_Biased_Climb();
bool   Non_Crossing_Biased_Climb();
bool   Non_Crossing_Biased_Descend();
bool   Own_Below_Threat();
bool   Own_Above_Threat();
int  alt_sep_test();
void initialize()
{
    Positive_RA_Alt_Thresh[0] = 400;
    Positive_RA_Alt_Thresh[1] = 500;
    Positive_RA_Alt_Thresh[2] = 640;
    Positive_RA_Alt_Thresh[3] = 740;
}

int ALIM ()
{
 return Positive_RA_Alt_Thresh[Alt_Layer_Value];
}

int Inhibit_Biased_Climb ()
{
    return (Climb_Inhibit ? Up_Separation + NOZCROSS : Up_Separation);
}

bool Non_Crossing_Biased_Climb()
{
    int upward_preferred;
    int upward_crossing_situation;
    bool result;

    upward_preferred = Inhibit_Biased_Climb() > Down_Separation;
    if (upward_preferred)
    {
	result = !(Own_Below_Threat()) || ((Own_Below_Threat()) && (!(Down_Separation >= ALIM())));
    }
    else
    {	
	result = Own_Above_Threat() && (Cur_Vertical_Sep >= MINSEP) && (Up_Separation >= ALIM());
    }
    return result;
}

bool Non_Crossing_Biased_Descend()
{
    int upward_preferred;
    int upward_crossing_situation;
    bool result;

    upward_preferred = (Up_Separation + NOZCROSS) > Down_Separation;
    if (upward_preferred)
    {
	result = Own_Below_Threat() && (Cur_Vertical_Sep >= MINSEP) && (Down_Separation >= ALIM());
    }
    else
    {
	result = !(Own_Above_Threat()) || ((Own_Above_Threat()) && (Up_Separation >= ALIM()));
    }
    return result;
}

bool Own_Below_Threat()
{
    return (Own_Tracked_Alt < Other_Tracked_Alt);
}

bool Own_Above_Threat()
{
    return (Other_Tracked_Alt < Own_Tracked_Alt);
}

int alt_sep_test()
{
    bool enabled, tcas_equipped, intent_not_known;
    bool need_upward_RA, need_downward_RA;
    int alt_sep;

    enabled = High_Confidence && (Own_Tracked_Alt_Rate <= OLEV) && (Cur_Vertical_Sep > MAXALTDIFF);
    tcas_equipped = Other_Capability == TCAS_TA;
    intent_not_known = Two_of_Three_Reports_Valid && Other_RAC == NO_INTENT;
    
    alt_sep = UNRESOLVED;
    
    if (enabled && ((tcas_equipped && intent_not_known) || !tcas_equipped))
    {
	need_upward_RA = Non_Crossing_Biased_Climb() && Own_Below_Threat();
	need_downward_RA = Non_Crossing_Biased_Descend() && Own_Above_Threat();
	if (need_upward_RA && need_downward_RA) {
        /* unreachable: requires Own_Below_Threat and Own_Above_Threat
           to both be true - that requires Own_Tracked_Alt < Other_Tracked_Alt
           and Other_Tracked_Alt < Own_Tracked_Alt, which isn't possible */
	    alt_sep = UNRESOLVED;
	} else if (need_upward_RA)
	    alt_sep = UPWARD_RA;
	else if (need_downward_RA)
	    alt_sep = DOWNWARD_RA;
	else
	    alt_sep = UNRESOLVED;
    }
    
    return alt_sep;
}

main(int argc, char*argv[])
{

  initialize();
  Cur_Vertical_Sep =  860; 
  High_Confidence = 1; 
  Two_of_Three_Reports_Valid = 1; 
  Own_Tracked_Alt =  618; 
  Own_Tracked_Alt_Rate =  329; 
  Other_Tracked_Alt =  574; 
  Alt_Layer_Value =  4; 
  Up_Separation =  893; 
  Down_Separation =  914; 
  Other_RAC =  0; 
  Other_Capability =  2; 
  Climb_Inhibit =  0; 
  assert(alt_sep_test()==0);
}

HeapDbg/xPb

// Creates an array of un-aliased Data objects
class Etype { 
  
    public double value;
    public void setValue(double x)
    {
      value = x;
    }
}

class Add:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Sub:Etype{
  
  public Etype l;
  public Etype r;
  
}
class Mult:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Data{}
class Var:Etype{}
class Const:Etype{}


class Program {
    static object Run() {
        var res = new Data[10];
        
              
        Var []env = new Var[3];
        Const c = new Const();
        c.setValue(6);
        

        Sub sb  = new Sub();
        sb.r = env[0];
        sb.l = env[1];
        
        Add ad2 = new Add();
        ad2.l = env[1];
        ad2.r = c;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c;
        
        //Add exp = ad1;        
        
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
        return new { root = ad1 , variable = env };
        
        
    }
}

HeapDbg/g

using System;

class ListNode { public ListNode next; public Data data;}
class Data {public int val;}
public class Program
{
    public static object Run()
    {
ListNode res = null;

for(int i = 0; i < 10; ++i)
res = new ListNode {next = res, data = new Data()};

return res;
    }
}

HeapDbg/jr

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
namespace ThreadTest1
{
    
 class Program
    {
     
        static void Main(string[] args)
        {
          //  Console.WriteLine("[{0}] Main Start....", Thread.CurrentThread.ManagedThreadId);
            //for (int n = 0; n <= 10; n++)
            //{
            //    Thread t = new Thread(add1);
            //    Thread.Sleep(1000);
            //    t.Start();
               
                
            //}
           // ThreadPool.QueueUserWorkItem(add1);
           // add(10, 20);
            test obj = new test();
            obj.mul();
            //Console.WriteLine("[{0}] Main Done....", Thread.CurrentThread.ManagedThreadId);
           
            Console.ReadLine();
        }

       static void add(int a, int b)
        {
           
            int val = a + b;        
            Console.WriteLine("[{0}] Main Done....", Thread.CurrentThread.ManagedThreadId);
            Thread t = new Thread(add1);
            t.Start();
        }
      
       static void add1(object i)
       {

           Thread.Sleep(1000); 
           Console.WriteLine("[{0}] Add1 Done....", Thread.CurrentThread.ManagedThreadId);
           Console.WriteLine("[{0}] Add1 Done....", Thread.CurrentThread.IsThreadPoolThread);
       }


    }
   
 public class test
 {

     static Random rand = new Random();
    public void mul()
     {
         
        Thread t = new Thread (WriteY);          // Kick off a new thread
       
        t.Start();                               // running WriteY()
        Thread.Sleep(rand.Next(2000, 3000));
    // Simultaneously, do something on the main thread.
    for (int i = 0; i < 1000; i++) Console.Write ("x");
    Console.WriteLine("[{0}] mul Done....", Thread.CurrentThread.ManagedThreadId);
  }
 
  static void WriteY()
  {
      //Thread.Sleep(rand.Next(2000, 3000));
    for (int i = 0; i < 1000; i++) Console.Write ("y");
    Console.WriteLine("[{0}] write Done....", Thread.CurrentThread.ManagedThreadId);
  }

     }



     
 }

HeapDbg/O1

    /*
 * Fichero: EnviarMail.java
 * Autor: Chuidiang
 * Fecha: 5/04/07 18:14
 */
package mail;

import java.io.ObjectInputStream.GetField;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Properties;

import javax.mail.Message;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;


/**
 * Ejemplo de envio de correo simple con JavaMail
 *
 * @author Chuidiang
 *
  */
public class EnviarMail
{
    /**
     * main de prueba
     * @param args Se ignoran.
     */
    @SuppressWarnings("unchecked")
	public static void main(String[] args)
    {
    	ArrayList elements = new ArrayList();
    	elements.add(new Element("rodrigo","ricardo","ana_julia"));
    	elements.add(new Element("joaquin","ricardo","ana_julia"));
    	elements.add(new Element("cristobal","gabriel","marcela"));
    	elements.add(new Element("agustin","gabriel","marcela"));
    	elements.add(new Element("micaela","gabriel","marcela"));
    	elements.add(new Element("gabriel","antonio","anabela"));
    	elements.add(new Element("ana_julia","antonio","anabela"));
    	elements.add(new Element("ricardo","ireneo","norma"));
    	elements.add(new Element("ireneo","ireneo","norma"));
    	elements.add(new Element("pablo","ireneo","norma"));
//    	elements.add(new Element("acid","fire","sulfur"));
//    	elements.add(new Element("acid_rain","acid","rain"));
//    	elements.add(new Element("ai","computer","life"));
//    	elements.add(new Element("alcohol","water","fire"));
//    	elements.add(new Element("alien","space","life"));
//    	elements.add(new Element("aluminum","metal","electricity"));
//    	elements.add(new Element("ape","human","wool"));
//    	elements.add(new Element("aquaman","fish","human"));
//    	elements.add(new Element("aquarium","glass","fish"));
//    	elements.add(new Element("arable_land","soil","tool"));
//    	elements.add(new Element("ash","fire","dust"));
//    	elements.add(new Element("ashtray","ash","glass"));
//    	elements.add(new Element("baby","human","sex"));
//    	elements.add(new Element("bacterium","swamp","life"));
//    	elements.add(new Element("bank","money","brick_house"));
//    	elements.add(new Element("beach","water","sand"));
//    	elements.add(new Element("beast","soil","lizard"));
//    	elements.add(new Element("beer","alcohol","wheat"));
//    	elements.add(new Element("bird","air","egg"));
//    	elements.add(new Element("blood","hunter","bird"));
//    	elements.add(new Element("boat","water","wood"));
//    	elements.add(new Element("boiler","metal","steam"));
//    	elements.add(new Element("bomb","metal","gunpowder"));
//    	elements.add(new Element("bomber","plane","bomb"));
//    	elements.add(new Element("book","paper","feather"));
//    	elements.add(new Element("bread","fire","dough"));
//    	elements.add(new Element("brick","clay","fire"));
//    	elements.add(new Element("brick_house","concrete","brick"));
//    	elements.add(new Element("bug","soil","worm"));
//    	elements.add(new Element("bulb","electricity","glass"));
//    	elements.add(new Element("bungalow","hut","beach"));
//    	elements.add(new Element("business","money","human"));
//    	elements.add(new Element("butterfly","air","worm"));
//    	elements.add(new Element("cart","wood","wheel"));
//    	elements.add(new Element("caviar","fish","fish"));
//    	elements.add(new Element("cd","laser","book"));
//    	elements.add(new Element("cellphone","computer","radiowave"));
//    	elements.add(new Element("cement","clay","limestone"));
//    	elements.add(new Element("ceramics","clay","human"));
//    	elements.add(new Element("cigarette","paper","tobacco"));
//    	elements.add(new Element("clay","swamp","sand"));
//    	elements.add(new Element("cleaner","clobber","human"));
//    	elements.add(new Element("clobber","fabric","patient"));
//    	elements.add(new Element("clone","scientist","livestock"));
//    	elements.add(new Element("clothing","fabric","human"));
//    	elements.add(new Element("cloud","steam","air"));
//    	elements.add(new Element("coal","tree","fire"));
//    	elements.add(new Element("cockleshell","stone","plankton"));
//    	elements.add(new Element("coffee","seeds","energy"));
//    	elements.add(new Element("columbus","sailing_vessel","hero"));
//    	elements.add(new Element("computer","book","tv"));
//    	elements.add(new Element("concrete","water","cement"));
//    	elements.add(new Element("corpse","poison","human"));
//    	elements.add(new Element("cyborg","human","computer"));
//    	elements.add(new Element("developer","sex","computer"));
//    	elements.add(new Element("dinosaur","soil","egg"));
//    	elements.add(new Element("doctor","human","book"));
//    	elements.add(new Element("dough","water","flour"));
//    	elements.add(new Element("dragon","flying_dinosaur","fire"));
//    	elements.add(new Element("drinker","alcohol","human"));
//    	elements.add(new Element("dust","air","soil"));
//    	elements.add(new Element("egg","stone","life"));
//    	elements.add(new Element("electricity","scientist","energy"));
//    	elements.add(new Element("elixer","stone","philosopher"));
//    	elements.add(new Element("energy","air","fire"));
//    	elements.add(new Element("fabric","wool","tool"));
//    	elements.add(new Element("fart","peas","human"));
//    	elements.add(new Element("feather","bird","hunter"));
//    	elements.add(new Element("fern","swamp","moss"));
//    	elements.add(new Element("fire_golem","fire","life"));
//    	elements.add(new Element("firearms","weapon","gunpowder"));
//    	elements.add(new Element("fish","bacterium","plankton"));
//    	elements.add(new Element("flour","wheat","stone"));
//    	elements.add(new Element("flying_dinosaur","dinosaur","air"));
//    	elements.add(new Element("fried_egg","fire","egg"));
//    	elements.add(new Element("fried_meat","fire","meat"));
//    	elements.add(new Element("frog","fish","swamp"));
//    	elements.add(new Element("ghoul","zombie","corpse"));
//    	elements.add(new Element("glass","sand","fire"));
//    	elements.add(new Element("gold","elixer","any_other_element"));
//    	elements.add(new Element("golem","clay","life"));
//    	elements.add(new Element("grass","moss","soil"));
//    	elements.add(new Element("gunpowder","saltpeter","sulfur"));
//    	elements.add(new Element("hacker","pirate","internet"));
//    	elements.add(new Element("hero","warrior","dragon"));
//    	elements.add(new Element("hospital","brick_house","doctor"));
//    	elements.add(new Element("housemd","doctor","vicodin"));
//    	elements.add(new Element("human","golem","life"));
//    	elements.add(new Element("hunter","weapon","human"));
//    	elements.add(new Element("hut","stone","human"));
//    	elements.add(new Element("internet","computer","computer"));
//    	elements.add(new Element("japanese","human","rice"));
//    	elements.add(new Element("kamasutra","book","sex"));
//    	elements.add(new Element("katana","japanese","metal"));
//    	elements.add(new Element("lake","water","water"));
//    	elements.add(new Element("lamp","glass","fire"));
//    	elements.add(new Element("laser","radiowave","fire"));
//    	elements.add(new Element("lava","soil","fire"));
//    	elements.add(new Element("lava_golem","life","lava"));
//    	elements.add(new Element("life","energy","swamp"));
//    	elements.add(new Element("lighthouse","brick_house","lamp"));
//    	elements.add(new Element("limestone","stone","cockleshell"));
//    	elements.add(new Element("livestock","human","beast"));
//    	elements.add(new Element("lizard","snake","worm"));
//    	elements.add(new Element("manga","book","japanese"));
//    	elements.add(new Element("manure","livestock","grass"));
//    	elements.add(new Element("meat","hunter","bird"));
//    	elements.add(new Element("medicine","shaman","poison"));
//    	elements.add(new Element("mercury","fire","metal"));
//    	elements.add(new Element("metal","stone","fire"));
//    	elements.add(new Element("metal_golem","life","metal"));
//    	elements.add(new Element("meteorite","space","stone"));
//    	elements.add(new Element("milk","livestock","human"));
//    	elements.add(new Element("money","gold","paper"));
//    	elements.add(new Element("moss","swamp","seaweed"));
//    	elements.add(new Element("murderer","poison_weapon","human"));
//    	elements.add(new Element("mushroom","soil","seaweed"));
//    	elements.add(new Element("new_york","usa","skyscraper"));
//    	elements.add(new Element("ninja","samuri","poison_weapon"));
//    	elements.add(new Element("nuclearbomb","scientist","bomb"));
//    	elements.add(new Element("ocean","sea","sea"));
//    	elements.add(new Element("oil","water","coal"));
//    	elements.add(new Element("paper","tool","reed"));
//    	elements.add(new Element("patient","bacterium","human"));
//    	elements.add(new Element("peas","arable_land","seeds"));
//    	elements.add(new Element("petrol","oil","tool"));
//    	elements.add(new Element("phantom","nuclearbomb","anything"));
//    	elements.add(new Element("philosopher","grass","scientist"));
//    	elements.add(new Element("phoenix","fire","bird"));
//    	elements.add(new Element("pig-iron","metal","coal"));
//    	elements.add(new Element("pilot","plane","human"));
//    	elements.add(new Element("pirate","murderer","sailing_vessel"));
//    	elements.add(new Element("plane","bird","aluminum"));
//    	elements.add(new Element("plankton","water","bacterium"));
//    	elements.add(new Element("poison","tool","scorpion"));
//    	elements.add(new Element("poison_weapon","poison","weapon"));
//    	elements.add(new Element("pub","beer","brick_house"));
//    	elements.add(new Element("radiation","nuclearbomb","anything"));
//    	elements.add(new Element("radiowave","metal","energy"));
//    	elements.add(new Element("rain","cloud","water"));
//    	elements.add(new Element("reed","swamp","grass"));
//    	elements.add(new Element("rice","arable_land","reed"));
//    	elements.add(new Element("robot","japanese","tool"));
//    	elements.add(new Element("rocket","plane","gunpowder"));
//    	elements.add(new Element("rust","water","metal"));
//    	elements.add(new Element("sailing_boat","boat","fabric"));
//    	elements.add(new Element("sailing_vessel","wooden_ship","fabric"));
//    	elements.add(new Element("salt","metal","acid"));
//    	elements.add(new Element("saltpeter","manure","limestone"));
//    	elements.add(new Element("samurai","japanese","weapon"));
//    	elements.add(new Element("sand","water","stone"));
//    	elements.add(new Element("scientist","doctor","book"));
//    	elements.add(new Element("scorpion","bug","sand"));
//    	elements.add(new Element("sea","lake","salt"));
//    	elements.add(new Element("seaweed","life","water"));
//    	elements.add(new Element("seeds","life","sand"));
//    	elements.add(new Element("sex","human","human"));
//    	elements.add(new Element("shaman","mushroom","human"));
//    	elements.add(new Element("shop","clothing","brickhouse"));
//    	elements.add(new Element("skydiver","clobber","pilot"));
//    	elements.add(new Element("skyscraper","brickhouse","glass"));
//    	elements.add(new Element("snake","sand","worm"));
//    	elements.add(new Element("sniper","firearms","murderer"));
//    	elements.add(new Element("space","ocean","air"));
//    	elements.add(new Element("speedboat","boat","rocket"));
//    	elements.add(new Element("starwars","laser","weapon"));
//    	elements.add(new Element("steam","water","air"));
//    	elements.add(new Element("steam_engine","boiler","coal"));
//    	elements.add(new Element("steam_locomotive","steam_engine","cart"));
//    	elements.add(new Element("steamship","wooden_ship","steam_engine"));
//    	elements.add(new Element("stone","water","lava"));
//    	elements.add(new Element("storm","energy","air"));
//    	elements.add(new Element("submarine","whale","metal"));
//    	elements.add(new Element("submariner","submarine","human"));
//    	elements.add(new Element("sulfur","swamp","bacterium"));
//    	elements.add(new Element("sun","lava","space"));
//    	elements.add(new Element("swamp","water","soil"));
//    	elements.add(new Element("team","cart","beast"));
//    	elements.add(new Element("terrorist","bomb","murderer"));
//    	elements.add(new Element("thunderbird","storm","bird"));
//    	elements.add(new Element("tobacco","fire","grass"));
//    	elements.add(new Element("tool","human","metal"));
//    	elements.add(new Element("torpedo","rocket","water"));
//    	elements.add(new Element("toy","baby","anything"));
//    	elements.add(new Element("tree","soil","seeds"));
//    	elements.add(new Element("turtle","egg","sand"));
//    	elements.add(new Element("tv","radiowave","bulb"));
//    	elements.add(new Element("ufo","alien","rocket"));
//    	elements.add(new Element("usa","columbus","ocean"));
//    	elements.add(new Element("vampire","human","blood"));
//    	elements.add(new Element("vicodin","medicine","medicine"));
//    	elements.add(new Element("vodka","water","alcohol"));
//    	elements.add(new Element("walking_tree","life","tree"));
//    	elements.add(new Element("war","warrior","warrior"));
//    	elements.add(new Element("werewolf","vampire","beast"));
//    	elements.add(new Element("warrior","weapon","hunter"));
//    	elements.add(new Element("warship","wooden_ship","weapon"));
//    	elements.add(new Element("weapon","tool","metal"));
//    	elements.add(new Element("whale","fish","plankton"));
//    	elements.add(new Element("wheat","arable_land","grass"));
//    	elements.add(new Element("wheel","wood","tool"));
//    	elements.add(new Element("wood","tree","tool"));
//    	elements.add(new Element("wooden_ship","wood","boat"));
//    	elements.add(new Element("wool","beast","hunter"));
//    	elements.add(new Element("worm","bacterium","swamp"));
//    	elements.add(new Element("yogurt","milk","bacterium"));
//    	elements.add(new Element("zombie","life","corpse"));

//    	elements.add(new Element("soil","basic element"));
//    	elements.add(new Element("air","basic element"));
//    	elements.add(new Element("fire","basic element"));
//    	elements.add(new Element("water","basic element"));

    	HashMap parents = new HashMap();
    	for (int i = 0 ; i < elements.size(); i++){
    		Element element = (Element) elements.get(i);
    		if ( parents.containsKey(element.getFather()) ) {
    			Parent parent = (Parent) parents.get(element.getFather());
    			parent.addChild(element.getName());
    		} else {
    			parents.put(element.getFather(), new Parent( element.getFather(), element.getName()));
    		};
    		if ( parents.containsKey(element.getMother()) ) {
    			Parent parent = (Parent) parents.get(element.getMother());
    			parent.addChild(element.getName());
    		} else {
    			parents.put(element.getMother(), new Parent( element.getMother(), element.getName()));
    		};
    	}
    	
    	Collection parentsSimple = parents.values();
    	Iterator iterParent = parentsSimple.iterator();
//    	for (int i = 0 ; i < elements.size(); i++){
////    		if (((Element) elements.get(i)).getName().equals("housemd")){
//    		if (!( parents.containsKey(((Element) elements.get(i)).getName()))){
//        		System.out.println("digraph " + i + " {");
//        		drawAscendenceForElements((Element) elements.get(i), (ArrayList) elements.clone());
//        		System.out.println("}\n");
//    		}
//    	}
    	// drawing complete
    	System.out.println("digraph g {");
    	while (iterParent.hasNext()){
    		Parent parent = (Parent) (iterParent.next());
    		Object[] childs = parent.getChilds();
			for (int j = 0; j < childs.length; j++) {
				System.out.println(parent.getName() + " -> " + (String) childs[j]);
			}
    	}
    	System.out.println("}\n");
    	
    	/**
        try
        {
            // Propiedades de la conexión
            Properties props = new Properties();
            props.setProperty("mail.smtp.host", "smtp.gmail.com");
            props.setProperty("mail.smtp.starttls.enable", "true");
            props.setProperty("mail.smtp.port", "587");
            props.setProperty("mail.smtp.user", "rodrigo.peti@gmail.com");
            props.setProperty("mail.smtp.auth", "true");
            // Preparamos la sesion
            Session session = Session.getDefaultInstance(props);

            // Construimos el mensaje
            MimeMessage message = new MimeMessage(session);
            message.setFrom(new InternetAddress("rodrigo.peti@gmail.com"));
            message.addRecipient(
                    Message.RecipientType.TO,
                    new InternetAddress("rmolina@intelap.com"));
            message.setText(
                "Mensajito con Java Mail" + " de los buenos." + "poque si" + " funciona papa! ");

            // Lo enviamos.
            Transport t = session.getTransport("smtp");
            t.connect("smtp.gmail.com", "rodrigo.peti@gmail.com", "rodrorodro");
//            t.connect("rodrigo.peti@gmail.com", "rodrorodro");
            t.sendMessage(message, message.getAllRecipients());

            // Cierre.
            t.close();
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        */
    }

	private static void drawAscendenceForElements(Element element,
			ArrayList anotherElements) {
		if (element!=null){
			Element father = getElement( element.getFather(), anotherElements); 
			anotherElements.remove(father);
			Element mother = getElement( element.getMother(), anotherElements);
			anotherElements.remove(mother);
			drawAscendenceForElements(father, anotherElements);
			drawAscendenceForElements(mother, anotherElements);
			System.out.println( element.getFather() + " -> " + element.getName());
			System.out.println( element.getMother() + " -> " + element.getName());
		}
		
	}

	private static Element getElement(String parent, ArrayList anotherElements) {
		for (int i = 0; i < anotherElements.size(); i++){
			Element element = (Element) anotherElements.get(i);
			if (element.getName().equals(parent)){
				return element;
			}
		}
		return null;
	}
}

HeapDbg/IT

/**
 * Ejemplo de envio de correo simple con JavaMail
 *
 * @author Chuidiang
 *
  */
public class EnviarMail
{
    /**
     * main de prueba
     * @param args Se ignoran.
     */
    @SuppressWarnings("unchecked")
	public static void main(String[] args)
    {
    	ArrayList elements = new ArrayList();
    	elements.add(new Element("rodrigo","ricardo","ana_julia"));
    	elements.add(new Element("joaquin","ricardo","ana_julia"));
    	elements.add(new Element("cristobal","gabriel","marcela"));
    	elements.add(new Element("agustin","gabriel","marcela"));
    	elements.add(new Element("micaela","gabriel","marcela"));
    	elements.add(new Element("gabriel","antonio","anabela"));
    	elements.add(new Element("ana_julia","antonio","anabela"));
    	elements.add(new Element("ricardo","ireneo","norma"));
    	elements.add(new Element("ireneo","ireneo","norma"));
    	elements.add(new Element("pablo","ireneo","norma"));
//    	elements.add(new Element("acid","fire","sulfur"));
//    	elements.add(new Element("acid_rain","acid","rain"));
//    	elements.add(new Element("ai","computer","life"));
//    	elements.add(new Element("alcohol","water","fire"));
//    	elements.add(new Element("alien","space","life"));
//    	elements.add(new Element("aluminum","metal","electricity"));
//    	elements.add(new Element("ape","human","wool"));
//    	elements.add(new Element("aquaman","fish","human"));
//    	elements.add(new Element("aquarium","glass","fish"));
//    	elements.add(new Element("arable_land","soil","tool"));
//    	elements.add(new Element("ash","fire","dust"));
//    	elements.add(new Element("ashtray","ash","glass"));
//    	elements.add(new Element("baby","human","sex"));
//    	elements.add(new Element("bacterium","swamp","life"));
//    	elements.add(new Element("bank","money","brick_house"));
//    	elements.add(new Element("beach","water","sand"));
//    	elements.add(new Element("beast","soil","lizard"));
//    	elements.add(new Element("beer","alcohol","wheat"));
//    	elements.add(new Element("bird","air","egg"));
//    	elements.add(new Element("blood","hunter","bird"));
//    	elements.add(new Element("boat","water","wood"));
//    	elements.add(new Element("boiler","metal","steam"));
//    	elements.add(new Element("bomb","metal","gunpowder"));
//    	elements.add(new Element("bomber","plane","bomb"));
//    	elements.add(new Element("book","paper","feather"));
//    	elements.add(new Element("bread","fire","dough"));
//    	elements.add(new Element("brick","clay","fire"));
//    	elements.add(new Element("brick_house","concrete","brick"));
//    	elements.add(new Element("bug","soil","worm"));
//    	elements.add(new Element("bulb","electricity","glass"));
//    	elements.add(new Element("bungalow","hut","beach"));
//    	elements.add(new Element("business","money","human"));
//    	elements.add(new Element("butterfly","air","worm"));
//    	elements.add(new Element("cart","wood","wheel"));
//    	elements.add(new Element("caviar","fish","fish"));
//    	elements.add(new Element("cd","laser","book"));
//    	elements.add(new Element("cellphone","computer","radiowave"));
//    	elements.add(new Element("cement","clay","limestone"));
//    	elements.add(new Element("ceramics","clay","human"));
//    	elements.add(new Element("cigarette","paper","tobacco"));
//    	elements.add(new Element("clay","swamp","sand"));
//    	elements.add(new Element("cleaner","clobber","human"));
//    	elements.add(new Element("clobber","fabric","patient"));
//    	elements.add(new Element("clone","scientist","livestock"));
//    	elements.add(new Element("clothing","fabric","human"));
//    	elements.add(new Element("cloud","steam","air"));
//    	elements.add(new Element("coal","tree","fire"));
//    	elements.add(new Element("cockleshell","stone","plankton"));
//    	elements.add(new Element("coffee","seeds","energy"));
//    	elements.add(new Element("columbus","sailing_vessel","hero"));
//    	elements.add(new Element("computer","book","tv"));
//    	elements.add(new Element("concrete","water","cement"));
//    	elements.add(new Element("corpse","poison","human"));
//    	elements.add(new Element("cyborg","human","computer"));
//    	elements.add(new Element("developer","sex","computer"));
//    	elements.add(new Element("dinosaur","soil","egg"));
//    	elements.add(new Element("doctor","human","book"));
//    	elements.add(new Element("dough","water","flour"));
//    	elements.add(new Element("dragon","flying_dinosaur","fire"));
//    	elements.add(new Element("drinker","alcohol","human"));
//    	elements.add(new Element("dust","air","soil"));
//    	elements.add(new Element("egg","stone","life"));
//    	elements.add(new Element("electricity","scientist","energy"));
//    	elements.add(new Element("elixer","stone","philosopher"));
//    	elements.add(new Element("energy","air","fire"));
//    	elements.add(new Element("fabric","wool","tool"));
//    	elements.add(new Element("fart","peas","human"));
//    	elements.add(new Element("feather","bird","hunter"));
//    	elements.add(new Element("fern","swamp","moss"));
//    	elements.add(new Element("fire_golem","fire","life"));
//    	elements.add(new Element("firearms","weapon","gunpowder"));
//    	elements.add(new Element("fish","bacterium","plankton"));
//    	elements.add(new Element("flour","wheat","stone"));
//    	elements.add(new Element("flying_dinosaur","dinosaur","air"));
//    	elements.add(new Element("fried_egg","fire","egg"));
//    	elements.add(new Element("fried_meat","fire","meat"));
//    	elements.add(new Element("frog","fish","swamp"));
//    	elements.add(new Element("ghoul","zombie","corpse"));
//    	elements.add(new Element("glass","sand","fire"));
//    	elements.add(new Element("gold","elixer","any_other_element"));
//    	elements.add(new Element("golem","clay","life"));
//    	elements.add(new Element("grass","moss","soil"));
//    	elements.add(new Element("gunpowder","saltpeter","sulfur"));
//    	elements.add(new Element("hacker","pirate","internet"));
//    	elements.add(new Element("hero","warrior","dragon"));
//    	elements.add(new Element("hospital","brick_house","doctor"));
//    	elements.add(new Element("housemd","doctor","vicodin"));
//    	elements.add(new Element("human","golem","life"));
//    	elements.add(new Element("hunter","weapon","human"));
//    	elements.add(new Element("hut","stone","human"));
//    	elements.add(new Element("internet","computer","computer"));
//    	elements.add(new Element("japanese","human","rice"));
//    	elements.add(new Element("kamasutra","book","sex"));
//    	elements.add(new Element("katana","japanese","metal"));
//    	elements.add(new Element("lake","water","water"));
//    	elements.add(new Element("lamp","glass","fire"));
//    	elements.add(new Element("laser","radiowave","fire"));
//    	elements.add(new Element("lava","soil","fire"));
//    	elements.add(new Element("lava_golem","life","lava"));
//    	elements.add(new Element("life","energy","swamp"));
//    	elements.add(new Element("lighthouse","brick_house","lamp"));
//    	elements.add(new Element("limestone","stone","cockleshell"));
//    	elements.add(new Element("livestock","human","beast"));
//    	elements.add(new Element("lizard","snake","worm"));
//    	elements.add(new Element("manga","book","japanese"));
//    	elements.add(new Element("manure","livestock","grass"));
//    	elements.add(new Element("meat","hunter","bird"));
//    	elements.add(new Element("medicine","shaman","poison"));
//    	elements.add(new Element("mercury","fire","metal"));
//    	elements.add(new Element("metal","stone","fire"));
//    	elements.add(new Element("metal_golem","life","metal"));
//    	elements.add(new Element("meteorite","space","stone"));
//    	elements.add(new Element("milk","livestock","human"));
//    	elements.add(new Element("money","gold","paper"));
//    	elements.add(new Element("moss","swamp","seaweed"));
//    	elements.add(new Element("murderer","poison_weapon","human"));
//    	elements.add(new Element("mushroom","soil","seaweed"));
//    	elements.add(new Element("new_york","usa","skyscraper"));
//    	elements.add(new Element("ninja","samuri","poison_weapon"));
//    	elements.add(new Element("nuclearbomb","scientist","bomb"));
//    	elements.add(new Element("ocean","sea","sea"));
//    	elements.add(new Element("oil","water","coal"));
//    	elements.add(new Element("paper","tool","reed"));
//    	elements.add(new Element("patient","bacterium","human"));
//    	elements.add(new Element("peas","arable_land","seeds"));
//    	elements.add(new Element("petrol","oil","tool"));
//    	elements.add(new Element("phantom","nuclearbomb","anything"));
//    	elements.add(new Element("philosopher","grass","scientist"));
//    	elements.add(new Element("phoenix","fire","bird"));
//    	elements.add(new Element("pig-iron","metal","coal"));
//    	elements.add(new Element("pilot","plane","human"));
//    	elements.add(new Element("pirate","murderer","sailing_vessel"));
//    	elements.add(new Element("plane","bird","aluminum"));
//    	elements.add(new Element("plankton","water","bacterium"));
//    	elements.add(new Element("poison","tool","scorpion"));
//    	elements.add(new Element("poison_weapon","poison","weapon"));
//    	elements.add(new Element("pub","beer","brick_house"));
//    	elements.add(new Element("radiation","nuclearbomb","anything"));
//    	elements.add(new Element("radiowave","metal","energy"));
//    	elements.add(new Element("rain","cloud","water"));
//    	elements.add(new Element("reed","swamp","grass"));
//    	elements.add(new Element("rice","arable_land","reed"));
//    	elements.add(new Element("robot","japanese","tool"));
//    	elements.add(new Element("rocket","plane","gunpowder"));
//    	elements.add(new Element("rust","water","metal"));
//    	elements.add(new Element("sailing_boat","boat","fabric"));
//    	elements.add(new Element("sailing_vessel","wooden_ship","fabric"));
//    	elements.add(new Element("salt","metal","acid"));
//    	elements.add(new Element("saltpeter","manure","limestone"));
//    	elements.add(new Element("samurai","japanese","weapon"));
//    	elements.add(new Element("sand","water","stone"));
//    	elements.add(new Element("scientist","doctor","book"));
//    	elements.add(new Element("scorpion","bug","sand"));
//    	elements.add(new Element("sea","lake","salt"));
//    	elements.add(new Element("seaweed","life","water"));
//    	elements.add(new Element("seeds","life","sand"));
//    	elements.add(new Element("sex","human","human"));
//    	elements.add(new Element("shaman","mushroom","human"));
//    	elements.add(new Element("shop","clothing","brickhouse"));
//    	elements.add(new Element("skydiver","clobber","pilot"));
//    	elements.add(new Element("skyscraper","brickhouse","glass"));
//    	elements.add(new Element("snake","sand","worm"));
//    	elements.add(new Element("sniper","firearms","murderer"));
//    	elements.add(new Element("space","ocean","air"));
//    	elements.add(new Element("speedboat","boat","rocket"));
//    	elements.add(new Element("starwars","laser","weapon"));
//    	elements.add(new Element("steam","water","air"));
//    	elements.add(new Element("steam_engine","boiler","coal"));
//    	elements.add(new Element("steam_locomotive","steam_engine","cart"));
//    	elements.add(new Element("steamship","wooden_ship","steam_engine"));
//    	elements.add(new Element("stone","water","lava"));
//    	elements.add(new Element("storm","energy","air"));
//    	elements.add(new Element("submarine","whale","metal"));
//    	elements.add(new Element("submariner","submarine","human"));
//    	elements.add(new Element("sulfur","swamp","bacterium"));
//    	elements.add(new Element("sun","lava","space"));
//    	elements.add(new Element("swamp","water","soil"));
//    	elements.add(new Element("team","cart","beast"));
//    	elements.add(new Element("terrorist","bomb","murderer"));
//    	elements.add(new Element("thunderbird","storm","bird"));
//    	elements.add(new Element("tobacco","fire","grass"));
//    	elements.add(new Element("tool","human","metal"));
//    	elements.add(new Element("torpedo","rocket","water"));
//    	elements.add(new Element("toy","baby","anything"));
//    	elements.add(new Element("tree","soil","seeds"));
//    	elements.add(new Element("turtle","egg","sand"));
//    	elements.add(new Element("tv","radiowave","bulb"));
//    	elements.add(new Element("ufo","alien","rocket"));
//    	elements.add(new Element("usa","columbus","ocean"));
//    	elements.add(new Element("vampire","human","blood"));
//    	elements.add(new Element("vicodin","medicine","medicine"));
//    	elements.add(new Element("vodka","water","alcohol"));
//    	elements.add(new Element("walking_tree","life","tree"));
//    	elements.add(new Element("war","warrior","warrior"));
//    	elements.add(new Element("werewolf","vampire","beast"));
//    	elements.add(new Element("warrior","weapon","hunter"));
//    	elements.add(new Element("warship","wooden_ship","weapon"));
//    	elements.add(new Element("weapon","tool","metal"));
//    	elements.add(new Element("whale","fish","plankton"));
//    	elements.add(new Element("wheat","arable_land","grass"));
//    	elements.add(new Element("wheel","wood","tool"));
//    	elements.add(new Element("wood","tree","tool"));
//    	elements.add(new Element("wooden_ship","wood","boat"));
//    	elements.add(new Element("wool","beast","hunter"));
//    	elements.add(new Element("worm","bacterium","swamp"));
//    	elements.add(new Element("yogurt","milk","bacterium"));
//    	elements.add(new Element("zombie","life","corpse"));

//    	elements.add(new Element("soil","basic element"));
//    	elements.add(new Element("air","basic element"));
//    	elements.add(new Element("fire","basic element"));
//    	elements.add(new Element("water","basic element"));

    	HashMap parents = new HashMap();
    	for (int i = 0 ; i < elements.size(); i++){
    		Element element = (Element) elements.get(i);
    		if ( parents.containsKey(element.getFather()) ) {
    			Parent parent = (Parent) parents.get(element.getFather());
    			parent.addChild(element.getName());
    		} else {
    			parents.put(element.getFather(), new Parent( element.getFather(), element.getName()));
    		};
    		if ( parents.containsKey(element.getMother()) ) {
    			Parent parent = (Parent) parents.get(element.getMother());
    			parent.addChild(element.getName());
    		} else {
    			parents.put(element.getMother(), new Parent( element.getMother(), element.getName()));
    		};
    	}
    	
    	Collection parentsSimple = parents.values();
    	Iterator iterParent = parentsSimple.iterator();
//    	for (int i = 0 ; i < elements.size(); i++){
////    		if (((Element) elements.get(i)).getName().equals("housemd")){
//    		if (!( parents.containsKey(((Element) elements.get(i)).getName()))){
//        		System.out.println("digraph " + i + " {");
//        		drawAscendenceForElements((Element) elements.get(i), (ArrayList) elements.clone());
//        		System.out.println("}\n");
//    		}
//    	}
    	// drawing complete
    	System.out.println("digraph g {");
    	while (iterParent.hasNext()){
    		Parent parent = (Parent) (iterParent.next());
    		Object[] childs = parent.getChilds();
			for (int j = 0; j < childs.length; j++) {
				System.out.println(parent.getName() + " -> " + (String) childs[j]);
			}
    	}
    	System.out.println("}\n");
    	
    	/**
        try
        {
            // Propiedades de la conexión
            Properties props = new Properties();
            props.setProperty("mail.smtp.host", "smtp.gmail.com");
            props.setProperty("mail.smtp.starttls.enable", "true");
            props.setProperty("mail.smtp.port", "587");
            props.setProperty("mail.smtp.user", "rodrigo.peti@gmail.com");
            props.setProperty("mail.smtp.auth", "true");
            // Preparamos la sesion
            Session session = Session.getDefaultInstance(props);

            // Construimos el mensaje
            MimeMessage message = new MimeMessage(session);
            message.setFrom(new InternetAddress("rodrigo.peti@gmail.com"));
            message.addRecipient(
                    Message.RecipientType.TO,
                    new InternetAddress("rmolina@intelap.com"));
            message.setText(
                "Mensajito con Java Mail" + " de los buenos." + "poque si" + " funciona papa! ");

            // Lo enviamos.
            Transport t = session.getTransport("smtp");
            t.connect("smtp.gmail.com", "rodrigo.peti@gmail.com", "rodrorodro");
//            t.connect("rodrigo.peti@gmail.com", "rodrorodro");
            t.sendMessage(message, message.getAllRecipients());

            // Cierre.
            t.close();
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        */
    }

	private static void drawAscendenceForElements(Element element,
			ArrayList anotherElements) {
		if (element!=null){
			Element father = getElement( element.getFather(), anotherElements); 
			anotherElements.remove(father);
			Element mother = getElement( element.getMother(), anotherElements);
			anotherElements.remove(mother);
			drawAscendenceForElements(father, anotherElements);
			drawAscendenceForElements(mother, anotherElements);
			System.out.println( element.getFather() + " -> " + element.getName());
			System.out.println( element.getMother() + " -> " + element.getName());
		}
		
	}

	private static Element getElement(String parent, ArrayList anotherElements) {
		for (int i = 0; i < anotherElements.size(); i++){
			Element element = (Element) anotherElements.get(i);
			if (element.getName().equals(parent)){
				return element;
			}
		}
		return null;
	}
}

HeapDbg/XNP

// Create an array of un-aliased Data objects and one special object
class Data { public int val;}
class Program {
    static object Run() {
        var resa = new Data[10];
        var dspecial = new Data();
        for (int i = 0; i < resa.Length; ++i) {
            if (i == 5)
                resa[i] = dspecial;
            else
                resa[i] = new Data();
        }
        return new { array = resa, special = dspecial };
    }
}

HeapDbg/pl

/**
 * Ejemplo de envio de correo simple con JavaMail
 *
 * @author Chuidiang
 *
  */
class EnviarMail
{
    /**
     * main de prueba
     * @param args Se ignoran.
     */
    @SuppressWarnings("unchecked")
	public static void main(String[] args)
    {
    	ArrayList elements = new ArrayList();
    	elements.add(new Element("rodrigo","ricardo","ana_julia"));
    	elements.add(new Element("joaquin","ricardo","ana_julia"));
    	elements.add(new Element("cristobal","gabriel","marcela"));
    	elements.add(new Element("agustin","gabriel","marcela"));
    	elements.add(new Element("micaela","gabriel","marcela"));
    	elements.add(new Element("gabriel","antonio","anabela"));
    	elements.add(new Element("ana_julia","antonio","anabela"));
    	elements.add(new Element("ricardo","ireneo","norma"));
    	elements.add(new Element("ireneo","ireneo","norma"));
    	elements.add(new Element("pablo","ireneo","norma"));
//    	elements.add(new Element("acid","fire","sulfur"));
//    	elements.add(new Element("acid_rain","acid","rain"));
//    	elements.add(new Element("ai","computer","life"));
//    	elements.add(new Element("alcohol","water","fire"));
//    	elements.add(new Element("alien","space","life"));
//    	elements.add(new Element("aluminum","metal","electricity"));
//    	elements.add(new Element("ape","human","wool"));
//    	elements.add(new Element("aquaman","fish","human"));
//    	elements.add(new Element("aquarium","glass","fish"));
//    	elements.add(new Element("arable_land","soil","tool"));
//    	elements.add(new Element("ash","fire","dust"));
//    	elements.add(new Element("ashtray","ash","glass"));
//    	elements.add(new Element("baby","human","sex"));
//    	elements.add(new Element("bacterium","swamp","life"));
//    	elements.add(new Element("bank","money","brick_house"));
//    	elements.add(new Element("beach","water","sand"));
//    	elements.add(new Element("beast","soil","lizard"));
//    	elements.add(new Element("beer","alcohol","wheat"));
//    	elements.add(new Element("bird","air","egg"));
//    	elements.add(new Element("blood","hunter","bird"));
//    	elements.add(new Element("boat","water","wood"));
//    	elements.add(new Element("boiler","metal","steam"));
//    	elements.add(new Element("bomb","metal","gunpowder"));
//    	elements.add(new Element("bomber","plane","bomb"));
//    	elements.add(new Element("book","paper","feather"));
//    	elements.add(new Element("bread","fire","dough"));
//    	elements.add(new Element("brick","clay","fire"));
//    	elements.add(new Element("brick_house","concrete","brick"));
//    	elements.add(new Element("bug","soil","worm"));
//    	elements.add(new Element("bulb","electricity","glass"));
//    	elements.add(new Element("bungalow","hut","beach"));
//    	elements.add(new Element("business","money","human"));
//    	elements.add(new Element("butterfly","air","worm"));
//    	elements.add(new Element("cart","wood","wheel"));
//    	elements.add(new Element("caviar","fish","fish"));
//    	elements.add(new Element("cd","laser","book"));
//    	elements.add(new Element("cellphone","computer","radiowave"));
//    	elements.add(new Element("cement","clay","limestone"));
//    	elements.add(new Element("ceramics","clay","human"));
//    	elements.add(new Element("cigarette","paper","tobacco"));
//    	elements.add(new Element("clay","swamp","sand"));
//    	elements.add(new Element("cleaner","clobber","human"));
//    	elements.add(new Element("clobber","fabric","patient"));
//    	elements.add(new Element("clone","scientist","livestock"));
//    	elements.add(new Element("clothing","fabric","human"));
//    	elements.add(new Element("cloud","steam","air"));
//    	elements.add(new Element("coal","tree","fire"));
//    	elements.add(new Element("cockleshell","stone","plankton"));
//    	elements.add(new Element("coffee","seeds","energy"));
//    	elements.add(new Element("columbus","sailing_vessel","hero"));
//    	elements.add(new Element("computer","book","tv"));
//    	elements.add(new Element("concrete","water","cement"));
//    	elements.add(new Element("corpse","poison","human"));
//    	elements.add(new Element("cyborg","human","computer"));
//    	elements.add(new Element("developer","sex","computer"));
//    	elements.add(new Element("dinosaur","soil","egg"));
//    	elements.add(new Element("doctor","human","book"));
//    	elements.add(new Element("dough","water","flour"));
//    	elements.add(new Element("dragon","flying_dinosaur","fire"));
//    	elements.add(new Element("drinker","alcohol","human"));
//    	elements.add(new Element("dust","air","soil"));
//    	elements.add(new Element("egg","stone","life"));
//    	elements.add(new Element("electricity","scientist","energy"));
//    	elements.add(new Element("elixer","stone","philosopher"));
//    	elements.add(new Element("energy","air","fire"));
//    	elements.add(new Element("fabric","wool","tool"));
//    	elements.add(new Element("fart","peas","human"));
//    	elements.add(new Element("feather","bird","hunter"));
//    	elements.add(new Element("fern","swamp","moss"));
//    	elements.add(new Element("fire_golem","fire","life"));
//    	elements.add(new Element("firearms","weapon","gunpowder"));
//    	elements.add(new Element("fish","bacterium","plankton"));
//    	elements.add(new Element("flour","wheat","stone"));
//    	elements.add(new Element("flying_dinosaur","dinosaur","air"));
//    	elements.add(new Element("fried_egg","fire","egg"));
//    	elements.add(new Element("fried_meat","fire","meat"));
//    	elements.add(new Element("frog","fish","swamp"));
//    	elements.add(new Element("ghoul","zombie","corpse"));
//    	elements.add(new Element("glass","sand","fire"));
//    	elements.add(new Element("gold","elixer","any_other_element"));
//    	elements.add(new Element("golem","clay","life"));
//    	elements.add(new Element("grass","moss","soil"));
//    	elements.add(new Element("gunpowder","saltpeter","sulfur"));
//    	elements.add(new Element("hacker","pirate","internet"));
//    	elements.add(new Element("hero","warrior","dragon"));
//    	elements.add(new Element("hospital","brick_house","doctor"));
//    	elements.add(new Element("housemd","doctor","vicodin"));
//    	elements.add(new Element("human","golem","life"));
//    	elements.add(new Element("hunter","weapon","human"));
//    	elements.add(new Element("hut","stone","human"));
//    	elements.add(new Element("internet","computer","computer"));
//    	elements.add(new Element("japanese","human","rice"));
//    	elements.add(new Element("kamasutra","book","sex"));
//    	elements.add(new Element("katana","japanese","metal"));
//    	elements.add(new Element("lake","water","water"));
//    	elements.add(new Element("lamp","glass","fire"));
//    	elements.add(new Element("laser","radiowave","fire"));
//    	elements.add(new Element("lava","soil","fire"));
//    	elements.add(new Element("lava_golem","life","lava"));
//    	elements.add(new Element("life","energy","swamp"));
//    	elements.add(new Element("lighthouse","brick_house","lamp"));
//    	elements.add(new Element("limestone","stone","cockleshell"));
//    	elements.add(new Element("livestock","human","beast"));
//    	elements.add(new Element("lizard","snake","worm"));
//    	elements.add(new Element("manga","book","japanese"));
//    	elements.add(new Element("manure","livestock","grass"));
//    	elements.add(new Element("meat","hunter","bird"));
//    	elements.add(new Element("medicine","shaman","poison"));
//    	elements.add(new Element("mercury","fire","metal"));
//    	elements.add(new Element("metal","stone","fire"));
//    	elements.add(new Element("metal_golem","life","metal"));
//    	elements.add(new Element("meteorite","space","stone"));
//    	elements.add(new Element("milk","livestock","human"));
//    	elements.add(new Element("money","gold","paper"));
//    	elements.add(new Element("moss","swamp","seaweed"));
//    	elements.add(new Element("murderer","poison_weapon","human"));
//    	elements.add(new Element("mushroom","soil","seaweed"));
//    	elements.add(new Element("new_york","usa","skyscraper"));
//    	elements.add(new Element("ninja","samuri","poison_weapon"));
//    	elements.add(new Element("nuclearbomb","scientist","bomb"));
//    	elements.add(new Element("ocean","sea","sea"));
//    	elements.add(new Element("oil","water","coal"));
//    	elements.add(new Element("paper","tool","reed"));
//    	elements.add(new Element("patient","bacterium","human"));
//    	elements.add(new Element("peas","arable_land","seeds"));
//    	elements.add(new Element("petrol","oil","tool"));
//    	elements.add(new Element("phantom","nuclearbomb","anything"));
//    	elements.add(new Element("philosopher","grass","scientist"));
//    	elements.add(new Element("phoenix","fire","bird"));
//    	elements.add(new Element("pig-iron","metal","coal"));
//    	elements.add(new Element("pilot","plane","human"));
//    	elements.add(new Element("pirate","murderer","sailing_vessel"));
//    	elements.add(new Element("plane","bird","aluminum"));
//    	elements.add(new Element("plankton","water","bacterium"));
//    	elements.add(new Element("poison","tool","scorpion"));
//    	elements.add(new Element("poison_weapon","poison","weapon"));
//    	elements.add(new Element("pub","beer","brick_house"));
//    	elements.add(new Element("radiation","nuclearbomb","anything"));
//    	elements.add(new Element("radiowave","metal","energy"));
//    	elements.add(new Element("rain","cloud","water"));
//    	elements.add(new Element("reed","swamp","grass"));
//    	elements.add(new Element("rice","arable_land","reed"));
//    	elements.add(new Element("robot","japanese","tool"));
//    	elements.add(new Element("rocket","plane","gunpowder"));
//    	elements.add(new Element("rust","water","metal"));
//    	elements.add(new Element("sailing_boat","boat","fabric"));
//    	elements.add(new Element("sailing_vessel","wooden_ship","fabric"));
//    	elements.add(new Element("salt","metal","acid"));
//    	elements.add(new Element("saltpeter","manure","limestone"));
//    	elements.add(new Element("samurai","japanese","weapon"));
//    	elements.add(new Element("sand","water","stone"));
//    	elements.add(new Element("scientist","doctor","book"));
//    	elements.add(new Element("scorpion","bug","sand"));
//    	elements.add(new Element("sea","lake","salt"));
//    	elements.add(new Element("seaweed","life","water"));
//    	elements.add(new Element("seeds","life","sand"));
//    	elements.add(new Element("sex","human","human"));
//    	elements.add(new Element("shaman","mushroom","human"));
//    	elements.add(new Element("shop","clothing","brickhouse"));
//    	elements.add(new Element("skydiver","clobber","pilot"));
//    	elements.add(new Element("skyscraper","brickhouse","glass"));
//    	elements.add(new Element("snake","sand","worm"));
//    	elements.add(new Element("sniper","firearms","murderer"));
//    	elements.add(new Element("space","ocean","air"));
//    	elements.add(new Element("speedboat","boat","rocket"));
//    	elements.add(new Element("starwars","laser","weapon"));
//    	elements.add(new Element("steam","water","air"));
//    	elements.add(new Element("steam_engine","boiler","coal"));
//    	elements.add(new Element("steam_locomotive","steam_engine","cart"));
//    	elements.add(new Element("steamship","wooden_ship","steam_engine"));
//    	elements.add(new Element("stone","water","lava"));
//    	elements.add(new Element("storm","energy","air"));
//    	elements.add(new Element("submarine","whale","metal"));
//    	elements.add(new Element("submariner","submarine","human"));
//    	elements.add(new Element("sulfur","swamp","bacterium"));
//    	elements.add(new Element("sun","lava","space"));
//    	elements.add(new Element("swamp","water","soil"));
//    	elements.add(new Element("team","cart","beast"));
//    	elements.add(new Element("terrorist","bomb","murderer"));
//    	elements.add(new Element("thunderbird","storm","bird"));
//    	elements.add(new Element("tobacco","fire","grass"));
//    	elements.add(new Element("tool","human","metal"));
//    	elements.add(new Element("torpedo","rocket","water"));
//    	elements.add(new Element("toy","baby","anything"));
//    	elements.add(new Element("tree","soil","seeds"));
//    	elements.add(new Element("turtle","egg","sand"));
//    	elements.add(new Element("tv","radiowave","bulb"));
//    	elements.add(new Element("ufo","alien","rocket"));
//    	elements.add(new Element("usa","columbus","ocean"));
//    	elements.add(new Element("vampire","human","blood"));
//    	elements.add(new Element("vicodin","medicine","medicine"));
//    	elements.add(new Element("vodka","water","alcohol"));
//    	elements.add(new Element("walking_tree","life","tree"));
//    	elements.add(new Element("war","warrior","warrior"));
//    	elements.add(new Element("werewolf","vampire","beast"));
//    	elements.add(new Element("warrior","weapon","hunter"));
//    	elements.add(new Element("warship","wooden_ship","weapon"));
//    	elements.add(new Element("weapon","tool","metal"));
//    	elements.add(new Element("whale","fish","plankton"));
//    	elements.add(new Element("wheat","arable_land","grass"));
//    	elements.add(new Element("wheel","wood","tool"));
//    	elements.add(new Element("wood","tree","tool"));
//    	elements.add(new Element("wooden_ship","wood","boat"));
//    	elements.add(new Element("wool","beast","hunter"));
//    	elements.add(new Element("worm","bacterium","swamp"));
//    	elements.add(new Element("yogurt","milk","bacterium"));
//    	elements.add(new Element("zombie","life","corpse"));

//    	elements.add(new Element("soil","basic element"));
//    	elements.add(new Element("air","basic element"));
//    	elements.add(new Element("fire","basic element"));
//    	elements.add(new Element("water","basic element"));

    	HashMap parents = new HashMap();
    	for (int i = 0 ; i < elements.size(); i++){
    		Element element = (Element) elements.get(i);
    		if ( parents.containsKey(element.getFather()) ) {
    			Parent parent = (Parent) parents.get(element.getFather());
    			parent.addChild(element.getName());
    		} else {
    			parents.put(element.getFather(), new Parent( element.getFather(), element.getName()));
    		};
    		if ( parents.containsKey(element.getMother()) ) {
    			Parent parent = (Parent) parents.get(element.getMother());
    			parent.addChild(element.getName());
    		} else {
    			parents.put(element.getMother(), new Parent( element.getMother(), element.getName()));
    		};
    	}
    	
    	Collection parentsSimple = parents.values();
    	Iterator iterParent = parentsSimple.iterator();
//    	for (int i = 0 ; i < elements.size(); i++){
////    		if (((Element) elements.get(i)).getName().equals("housemd")){
//    		if (!( parents.containsKey(((Element) elements.get(i)).getName()))){
//        		System.out.println("digraph " + i + " {");
//        		drawAscendenceForElements((Element) elements.get(i), (ArrayList) elements.clone());
//        		System.out.println("}\n");
//    		}
//    	}
    	// drawing complete
    	System.out.println("digraph g {");
    	while (iterParent.hasNext()){
    		Parent parent = (Parent) (iterParent.next());
    		Object[] childs = parent.getChilds();
			for (int j = 0; j < childs.length; j++) {
				System.out.println(parent.getName() + " -> " + (String) childs[j]);
			}
    	}
    	System.out.println("}\n");
    	
    	/**
        try
        {
            // Propiedades de la conexión
            Properties props = new Properties();
            props.setProperty("mail.smtp.host", "smtp.gmail.com");
            props.setProperty("mail.smtp.starttls.enable", "true");
            props.setProperty("mail.smtp.port", "587");
            props.setProperty("mail.smtp.user", "rodrigo.peti@gmail.com");
            props.setProperty("mail.smtp.auth", "true");
            // Preparamos la sesion
            Session session = Session.getDefaultInstance(props);

            // Construimos el mensaje
            MimeMessage message = new MimeMessage(session);
            message.setFrom(new InternetAddress("rodrigo.peti@gmail.com"));
            message.addRecipient(
                    Message.RecipientType.TO,
                    new InternetAddress("rmolina@intelap.com"));
            message.setText(
                "Mensajito con Java Mail" + " de los buenos." + "poque si" + " funciona papa! ");

            // Lo enviamos.
            Transport t = session.getTransport("smtp");
            t.connect("smtp.gmail.com", "rodrigo.peti@gmail.com", "rodrorodro");
//            t.connect("rodrigo.peti@gmail.com", "rodrorodro");
            t.sendMessage(message, message.getAllRecipients());

            // Cierre.
            t.close();
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        */
    }

	private static void drawAscendenceForElements(Element element,
			ArrayList anotherElements) {
		if (element!=null){
			Element father = getElement( element.getFather(), anotherElements); 
			anotherElements.remove(father);
			Element mother = getElement( element.getMother(), anotherElements);
			anotherElements.remove(mother);
			drawAscendenceForElements(father, anotherElements);
			drawAscendenceForElements(mother, anotherElements);
			System.out.println( element.getFather() + " -> " + element.getName());
			System.out.println( element.getMother() + " -> " + element.getName());
		}
		
	}

	private static Element getElement(String parent, ArrayList anotherElements) {
		for (int i = 0; i < anotherElements.size(); i++){
			Element element = (Element) anotherElements.get(i);
			if (element.getName().equals(parent)){
				return element;
			}
		}
		return null;
	}
}

HeapDbg/sf

// Creates an array of un-aliased Data objects
class Data { int a,b,c; }
class Program {
    static object Run() {
        var res = new Data[10,10];
        for (int i = 0; i < 10; ++i)
            res[i,0] = new Data;
        return new { root = res };
    }
}

HeapDbg/xl

// Creates an array of un-aliased Data objects
class Data { }
class Program {
    static object Run() {
        var res = new Data[10];
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
        return new { root = res };
    }vvfdy
}

HeapDbg/cV

public class TestHeapCloning
    {
        TestHeapCloning f;
        int h;
        public void foo(TestHeapCloning param)
        {
            TestHeapCloning local1 = bar();
            TestHeapCloning local2 = bar();
            local1.f = param;
            local2.f = new TestHeapCloning();
            local2.f.h = 1;
        }

        public TestHeapCloning bar()
        {
            TestHeapCloning r = new TestHeapCloning();
            return r;
        }
    }

HeapDbg/xc

// Creates an array of un-aliased Data objects
class Data { }
class Program {
    static object Run() {
        var res = new Data[10];
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
        return new { root = res };
    }
class items { }
}

HeapDbg/Xb

// Creates an array of un-aliased Data objects
class Data { int i; }
class Program {
    static object Run() {
        var res = { root = new Data[10] };
        for (int i = 0; i < res.Length; ++i)
            res.a[i] = new Data();
        return new { root = res };
    }
}

HeapDbg/0qh

// Creates a heap and returns each root as a field of the return object
class Hello { public World World; }
class World { }
class Program {
    static object Run() {
        var res = new Hello { World = new World() };
        return new { root = res };
    }
}

HeapDbg/xa

Reading this makes my deicosins easier than taking candy from a baby.

HeapDbg/Pe

using System;

public class TreeNode
	{
		public TreeNode left; public TreeNode right; public Data data;

		public static TreeNode MakeTree(int k)
		{
			if(k == 0)
				return null;
			else
				return new TreeNode { left = MakeTree(k - 1), right = MakeTree(k - 1), data = new Data() };
		}

		public static TreeNode CopyTreeShallow(TreeNode t)
		{
			if(t == null)
				return null;
			else
				return new TreeNode { left = MakeTree(t.left), right = MakeTree(t.right), data = t.data };
		}
	}

	public class Data { public int val;}
	public class Result { public TreeNode orig; public TreeNode copy;}

	public class Program
	{
		public static object Run()
		{
			TreeNode torig = TreeNode.MakeTree(3);
			TreeNode tcopy = TreeNode.CopyTreeShallow(orig);

			return new Result { orig = torig, copy = tcopy };
		}
	}

HeapDbg/rH

class Etype {} 

class Add:Etype{ public Etype l; public Etype r; }
class Sub:Etype{ public Etype l; public Etype r; }
class Mult:Etype{ public Etype l; public Etype r; }

class Var:Etype{}  
class Const:Etype{}


class Program {
    static object Run() {
              
        Var []env = new Var[3];
        
        Var v1= new Var();
        Var v2= new Var();
        Var v3= new Var();
        
        env[0] = v1;
        env[1] = v2;
        Const c1 = new Const();
        Const c2 = new Const();
       
     

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
                
        Add  exp = new Add();
        exp.l = ad1; 
        
        return new { exp , env };
        
        
    }
}

HeapDbg/RgS

// Creates an array of un-aliased Data objects
class Etype { 
  
    public double value;
    public void setValue(double x)
    {
      value = x;
    }
}

class Add:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Sub:Etype{
  
  public Etype l;
  public Etype r;
  
}
class Mult:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Data{}
class Var:Etype{}
class Const:Etype{}


class Program {
    static object Run() {
        var res = new Data[10];
        
              
        Var []env = new Var[3];
        Var v1 = null;
        Var v2 = null;
        
        env[0] = v1;
        env[0] = v2;
        
        Const c1 = new Const();
        Const c2 = new Const();
       
        

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
        var exp = ad1;        
        
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
        return new { root = exp , variable = env };
        
        
    }
}

HeapDbg/rG

using System;
using System.Collections.Generic;

public class Program
	{
		public static object Run()
		{
			Dictionary<Point, Sphere[]> nestedDict = new Dictionary<int, Sphere[]>();

			for(int i = 0; i < 10; ++i)
			{
				Sphere[] spheres = new Sphere[10];
				Color rgb = new Color { red = 0, blue = 255, green = 0 };

				for(int j = 0; j < 10; ++j)
				{
					Point ctr = new Point { xpos = i, ypos = i + j, zpos = i - j };
					spheres[i] = new Sphere { center = ctr, color = rgb, radius = 3.0F };
				}

				nestedDict.Add(spheres[0], spheres);
			}

			return nestedDict;
		}
	}

	public class Sphere { public Point center; public Color color; public float radius; }
	public class Color { public int red; public int blue; public int green; }
	public class Point { public float xpos; public float ypos; public float zpos; }

HeapDbg/re

// Creates an array of un-aliased Data objects
class Data { }
class Program {
    static object Run() {
var b = new { C = 1 };
var a = new { B = b };

return new { A = a };
    }
}

HeapDbg/wq1

//===============================================================================
// Microsoft patterns & practices Enterprise Library
// Caching Application Block
//===============================================================================
// Copyright © Microsoft Corporation.  All rights reserved.
// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY
// OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT
// LIMITED TO THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
// FITNESS FOR A PARTICULAR PURPOSE.
//===============================================================================

using System;
using System.Collections;
using System.Threading;
using Microsoft.Practices.EnterpriseLibrary.Caching.Properties;
using Microsoft.Practices.EnterpriseLibrary.Caching.Instrumentation;

namespace Microsoft.Practices.EnterpriseLibrary.Caching
{
    /// <summary>
    /// The real worker of the block. The Cache class is the traffic cop that prevents 
    /// resource contention among the different threads in the system. It also will act
    /// as the remoting gateway when that feature is added to the cache.
    /// </summary>	
    public class Cache : ICacheOperations, IDisposable
    {
        private Hashtable inMemoryCache;
        private IBackingStore backingStore;
        private ICachingInstrumentationProvider instrumentationProvider;

        private const string addInProgressFlag = "Dummy variable used to flag temp cache item added during Add";

        /// <summary>
        /// Initialzie a new instance of a <see cref="Cache"/> class with a backing store, and scavenging policy.
        /// </summary>
        /// <param name="backingStore">The cache backing store.</param>
        /// <param name="instrumentationProvider">The instrumentation provider.</param>
        public Cache(IBackingStore backingStore, ICachingInstrumentationProvider instrumentationProvider)
        {
            if (backingStore == null) throw new ArgumentNullException("backingStore");
            if (instrumentationProvider == null) throw new ArgumentNullException("instrumentationProvider");

            this.backingStore = backingStore;
            this.instrumentationProvider = instrumentationProvider;

            Hashtable initialItems = backingStore.Load();
            inMemoryCache = Hashtable.Synchronized(initialItems);

            this.instrumentationProvider.FireCacheUpdated(initialItems.Count, initialItems.Count);


        }

        /// <summary>
        /// Gets the count of <see cref="CacheItem"/> objects.
        /// </summary>
        /// <value>
        /// The count of <see cref="CacheItem"/> objects.
        /// </value>
        public int Count
        {
            get { return inMemoryCache.Count; }
        }

        /// <summary>
        /// Gets the current cache.
        /// </summary>
        /// <returns>
        /// The current cache.
        /// </returns>
        public Hashtable CurrentCacheState
        {
            get { return (Hashtable)inMemoryCache.Clone(); }
        }

        /// <summary>
        /// Determines if a particular key is contained in the cache.
        /// </summary>
        /// <param name="key">The key to locate.</param>
        /// <returns>
        /// <see langword="true"/> if the key is contained in the cache; otherwise, <see langword="false"/>.
        /// </returns>
        public bool Contains(string key)
        {
            ValidateKey(key);

            return inMemoryCache.Contains(key);
        }

        /// <summary>
        /// Add a new keyed object to the cache.
        /// </summary>
        /// <param name="key">The key of the object.</param>
        /// <param name="value">The object to add.</param>
        public void Add(string key, object value)
        {
            Add(key, value, CacheItemPriority.Normal, null);
        }

        /// <summary>
        /// Add a new keyed object to the cache.
        /// </summary>
        /// <param name="key">The key of the object.</param>
        /// <param name="value">The object to add.</param>
        /// <param name="scavengingPriority">One of the <see cref="CacheItemPriority"/> values.</param>
        /// <param name="refreshAction">An <see cref="ICacheItemRefreshAction"/> object.</param>
        /// <param name="expirations">An array of <see cref="ICacheItemExpiration"/> objects.</param>
        public CacheItem Add(string key, object value, CacheItemPriority scavengingPriority, ICacheItemRefreshAction refreshAction, params ICacheItemExpiration[] expirations)
        {
            ValidateKey(key);

            CacheItem cacheItemBeforeLock = null;
            bool lockWasSuccessful = false;

            do
            {
                lock (inMemoryCache.SyncRoot)
                {
                    if (inMemoryCache.Contains(key) == false)
                    {
                        cacheItemBeforeLock = new CacheItem(key, addInProgressFlag, CacheItemPriority.Normal, null);
                        inMemoryCache.Add(key,cacheItemBeforeLock);
                    }
                    else
                    {
                        cacheItemBeforeLock = (CacheItem)inMemoryCache[key];
                    }

                    lockWasSuccessful = Monitor.TryEnter(cacheItemBeforeLock);
                }

                if (lockWasSuccessful == false)
                {
                    Thread.Sleep(0);
                }
            } while (lockWasSuccessful == false);

            try
            {
                cacheItemBeforeLock.TouchedByUserAction(true);

                CacheItem newCacheItem = new CacheItem(key, value, scavengingPriority, refreshAction, expirations);
                try
                {
                    backingStore.Add(newCacheItem);
                    cacheItemBeforeLock.Replace(value, refreshAction, scavengingPriority, expirations);
                    if (inMemoryCache.Contains(key))
                    {
                        inMemoryCache.Remove(key);
                        inMemoryCache.Add(key, cacheItemBeforeLock);
                    }
                }
                catch
                {
                    backingStore.Remove(key);
                    inMemoryCache.Remove(key);
                    throw;
                }
                if (null != newCacheItem)
                    newCacheItem = null;

                instrumentationProvider.FireCacheUpdated(1, inMemoryCache.Count);
            }
            finally
            {
                Monitor.Exit(cacheItemBeforeLock);

            }
            return cacheItemBeforeLock;
        }

        /// <summary>
        /// Remove an item from the cache by key.
        /// </summary>
        /// <param name="key">The key of the item to remove.</param>
        public void Remove(string key)
        {
            Remove(key, CacheItemRemovedReason.Removed);
        }


        /// <summary>
        /// Added by senthil. 
        /// when the remove logic called by scavenger or Expirary task . 
        /// Check the cache is used by other machine if it is don't remove from back end
        /// </summary>
        /// <param name="item"></param>
        /// <returns></returns>
        public bool CanRemoveFromBackStoreCache(CacheItem item, CacheItemRemovedReason reason)
        {
            if (reason == CacheItemRemovedReason.Expired || reason == CacheItemRemovedReason.Scavenged)
            {
                if (item.LastAccessedTime < backingStore.GetLastAccessedTime(item.Key))
                    return false;
                return true;
            }
            return true;
        }


        /// <summary>
        /// Remove an item from the cache by key.
        /// </summary>
        /// <param name="key">The key of the item to remove.</param>
        /// <param name="removalReason">One of the <see cref="CacheItemRemovedReason"/> values.</param>
        public void Remove(string key, CacheItemRemovedReason removalReason)
        {
            ValidateKey(key);

            CacheItem cacheItemBeforeLock = null;
            bool lockWasSuccessful;
            do
            {
                lock (inMemoryCache.SyncRoot)
                {
                    cacheItemBeforeLock = (CacheItem)inMemoryCache[key];

                    if (IsObjectInCache(cacheItemBeforeLock))
                    {
                        return;
                    }

                    lockWasSuccessful = Monitor.TryEnter(cacheItemBeforeLock);
                }

                if (lockWasSuccessful == false)
                {
                    Thread.Sleep(0);
                }
            } while (lockWasSuccessful == false);

            try
            {
                cacheItemBeforeLock.TouchedByUserAction(true);
                ((CacheItem)inMemoryCache[key]).WillBeExpired = true;
                //Check if this is the owner of backend cache . If not don't remove memory
                if (CanRemoveFromBackStoreCache(cacheItemBeforeLock, removalReason))
                    backingStore.Remove(key); // Does exception safety matter here? We're removing it due to expiration or scavenging...
                inMemoryCache.Remove(key);

                RefreshActionInvoker.InvokeRefreshAction(cacheItemBeforeLock, removalReason, instrumentationProvider);

                instrumentationProvider.FireCacheUpdated(1, inMemoryCache.Count);
            }
            finally
            {
                Monitor.Exit(cacheItemBeforeLock);
            }
        }


        /// <summary>
        /// Removes an item from the cache.
        /// </summary>
        /// <param name="key">The key to remove.</param>
        /// <param name="removalReason">One of the <see cref="CacheItemRemovedReason"/> values.</param>
        /// <remarks>
        /// This seemingly redundant method is here to be called through the ICacheOperations 
        /// interface. I put this in place to break any dependency from any other class onto 
        /// the Cache class
        /// </remarks>
        public void RemoveItemFromCache(string key, CacheItemRemovedReason removalReason)
        {
            Remove(key, removalReason);
        }

        //static TimeSpan refreshTimeSpan = new TimeSpan(10000000);
        /// <summary>
        /// Get the object from the cache for the key.
        /// </summary>
        /// <param name="key">
        /// The key whose value to get.
        /// </param>
        /// <returns>
        /// The value associated with the specified key. 
        /// </returns>
        public object GetData(string key)
        {
            ValidateKey(key);
            CacheItem cacheItemBeforeLock = null;
            bool lockWasSuccessful = false;

            do
            {
                lock (inMemoryCache.SyncRoot)
                {
                    cacheItemBeforeLock = (CacheItem)inMemoryCache[key];
                    if (IsObjectInCache(cacheItemBeforeLock))
                    {
                        // Try to see the back end has key 
                        var obj = (CacheItem)this.backingStore.GetDataFromBackStoreCache(key);
                        if (obj != null)
                        {
                            cacheItemBeforeLock = obj;
                            inMemoryCache[key] = cacheItemBeforeLock;
                        }
                        else
                        {
                            instrumentationProvider.FireCacheAccessed(key, false);
                            return null;
                        }
                    }
                    else
                    {
                        //updated by senthil
                        if (cacheItemBeforeLock != null && cacheItemBeforeLock.FetchItFromBackStore == true)
                        {

                            if (cacheItemBeforeLock.LastAccessedTime <= this.backingStore.GetLastAccessedTime(cacheItemBeforeLock.Key))
                            {
                                //TimeSpan t = DateTime.Now - cacheItemBeforeLock.LastAccessedTime;
                                //if (t > refreshTimeSpan)
                                //{    // Try to see the back end has key 
                                var obj = (CacheItem)this.backingStore.GetDataFromBackStoreCache(key);
                                if (obj != null)
                                {
                                    cacheItemBeforeLock = obj;
                                    inMemoryCache[key] = cacheItemBeforeLock;
                                }

                            }
                        }
                    }

                    lockWasSuccessful = Monitor.TryEnter(cacheItemBeforeLock);
                }

                if (lockWasSuccessful == false)
                {
                    Thread.Sleep(0);
                }
            } while (lockWasSuccessful == false);

            try
            {

                if (cacheItemBeforeLock.HasExpired())
                {
                    cacheItemBeforeLock.TouchedByUserAction(true);

                    backingStore.Remove(key); // Does exception safety matter here? We're removing it due to expiration or scavenging...
                    inMemoryCache.Remove(key);

                    RefreshActionInvoker.InvokeRefreshAction(cacheItemBeforeLock, CacheItemRemovedReason.Expired, instrumentationProvider);

                    instrumentationProvider.FireCacheAccessed(key, false);
                    instrumentationProvider.FireCacheUpdated(1, inMemoryCache.Count);
                    instrumentationProvider.FireCacheExpired(1);
                    return null;
                }


                backingStore.UpdateLastAccessedTime(cacheItemBeforeLock.Key, DateTime.Now); // Does exception safety matter here?
                cacheItemBeforeLock.TouchedByUserAction(false);

                instrumentationProvider.FireCacheAccessed(key, true);
                return cacheItemBeforeLock.Value;
            }
            finally
            {
                Monitor.Exit(cacheItemBeforeLock);
            }
        }

        /// <summary>
        /// Flush the cache.
        /// </summary>
        /// <remarks>
        /// There may still be thread safety issues in this class with respect to cacheItemExpirations
        /// and scavenging, but I really doubt that either of those will be happening while
        /// a Flush is in progress. It seems that the most likely scenario for a flush
        /// to be called is at the very start of a program, or when absolutely nothing else
        /// is going on. Calling flush in the middle of an application would seem to be
        /// an "interesting" thing to do in normal circumstances.
        /// </remarks>
        public void Flush()
        {
        RestartFlushAlgorithm:
            lock (inMemoryCache.SyncRoot)
            {
                foreach (string key in inMemoryCache.Keys)
                {
                    bool lockWasSuccessful = false;
                    CacheItem itemToRemove = (CacheItem)inMemoryCache[key];
                    try
                    {
                        if (lockWasSuccessful = Monitor.TryEnter(itemToRemove))
                        {
                            itemToRemove.TouchedByUserAction(true);
                        }
                        else
                        {
                            goto RestartFlushAlgorithm;
                        }
                    }
                    finally
                    {
                        if (lockWasSuccessful) Monitor.Exit(itemToRemove);
                    }
                }

                int countBeforeFlushing = inMemoryCache.Count;

                backingStore.Flush();
                inMemoryCache.Clear();

                instrumentationProvider.FireCacheUpdated(countBeforeFlushing, 0);
            }
        }

        private static void ValidateKey(string key)
        {
            if (string.IsNullOrEmpty(key))
            {
                throw new ArgumentException(Resources.EmptyParameterName, "key");
            }
        }

        private static bool IsObjectInCache(CacheItem cacheItemBeforeLock)
        {
            return cacheItemBeforeLock == null || Object.ReferenceEquals(cacheItemBeforeLock.Value, addInProgressFlag);
        }


        /// <summary>
        /// Dispose of the backing store before garbage collection.
        /// </summary>
        ~Cache()
        {
            Dispose(false);
        }

        /// <summary>
        /// Dispose of the backing store before garbage collection.
        /// </summary>
        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        /// <summary>
        /// Dispose of the backing store before garbage collection.
        /// </summary>
        /// <param name="disposing">
        /// <see langword="true"/> if disposing; otherwise, <see langword="false"/>.
        /// </param>
        protected virtual void Dispose(bool disposing)
        {
            if (disposing)
            {
                backingStore.Dispose();
                backingStore = null;
            }
        }
    }
}

HeapDbg/KH

// Creates an array of un-aliased Data objects
class Data { }
class Program {
    static object Run() {
      return Run1();
    }

    static object Run1() {
        var res = new Data[];
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
        return new { root = res };
   }
}

HeapDbg/Wl

// Creates an array of un-aliased Data objects
class Data { private int prop; }
class Program {
    static object Run() {
        var res = new Data[10];
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
        return { root = new Data()//res };
    }
}

HeapDbg/Yh

using System;
using System.Collections.Generic;

public class Program
	{
		public static object Run()
		{
			Dictionary<Point, Sphere[]> nestedDict = new Dictionary<Point, Sphere[]>();

			for(int i = 0; i < 10; ++i)
			{
				Sphere[] spheres = new Sphere[10];
				Color rgb = new Color { red = 0, blue = 255, green = 0 };

				for(int j = 0; j < 10; ++j)
				{
					Point ctr = new Point { xpos = i, ypos = i + j, zpos = i - j };
					spheres[i] = new Sphere { center = ctr, color = rgb, radius = 3.0F };
				}

				nestedDict.Add(spheres[0].center, spheres);
			}

			return nestedDict;
		}
	}

	public class Sphere { public Point center; public Color color; public float radius; }
	public class Color { public int red; public int blue; public int green; }
	public class Point { public float xpos; public float ypos; public float zpos; }

HeapDbg/r2b

// Create a LinkedList of Data objects
// Self edge on, Next, and label, List

class Data { }
class Program {
    static object Run() {
        return "abc";
    }
}

HeapDbg/v

using System;
using System.Collections.Generic;

public class Program
	{
		public static object Run()
		{
			Dictionary<Point, Sphere[]> nestedDict = new Dictionary<int, Sphere[]>();

			for(int i = 0; i < 10; ++i)
			{
				Sphere[] spheres = new Sphere[10];
				Color rgb = new Color { red = 0, blue = 255, green = 0 };

				for(int j = 0; j < 10; ++j)
				{
					Point ctr = new Point { xpos = i, ypos = i + j, zpos = i - j };
					spheres[i] = new Sphere { center = ctr, color = rgb, radius = 3.0F };
				}

				nestedDict.Add(spheres[0].center, spheres);
			}

			return nestedDict;
		}
	}

	public class Sphere { public Point center; public Color color; public float radius; }
	public class Color { public int red; public int blue; public int green; }
	public class Point { public float xpos; public float ypos; public float zpos; }

HeapDbg/y0

// Creates an array of un-aliased Data objects
class Data { }
class Program {
    static object Run() {
        var res = new Data[10];
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
        return new { root = res };
    }
}

HeapDbg/R

using System;

class ListNode { public ListNode next; }
public class Program
{
    public static object Run()
    {
ListNode res = null;

for(int i = 0; i < 10; ++i)
res = new ListNode {next = res;};

return res;
    }
}

HeapDbg/Qz

// Creates an array of un-aliased Data objects
class Data { }
class Program {
    static object Run() {
        var res = new Data[10];
        for (int i = 0; i <gdvm ..thgh res.Length; ++i)
            res[i] = new Data();
        return new { root = res };
    }
}

HeapDbg/hw

// Creates a Deep Copy of a Tree of Data objects
class Data { public int Value;}
class TreeNode {
    public TreeNode Left; public TreeNode Right; 
    public Data Data;
    public static TreeNode MakeTree(int k) {
        if (k == 0)
            return null;
        else
            return new TreeNode { 
                Left = MakeTree(k - 1), Right = MakeTree(k - 1), 
                Data = new Data() 
            };
    }
    public static TreeNode CopyTreeDeep(TreeNode t) {
        if (t == null)
            return null;
        else
            return new TreeNode { 
                Left = CopyTreeDeep(t.Left), Right = CopyTreeDeep(t.Right), 
                Data = new Data { Value = t.Data.Value } 
            };
    }
}
class Program {
    static object Run() {
        var original = TreeNode.MakeTree(3);
        var copy = TreeNode.CopyTreeDeep(torig);

        return new { orig = original, copy = copy };
    }
}

HeapDbg/JM

// Creates an array of un-aliased Data objects
class Data { }
class Program {
    static object Run() {
        var res = new Data[100];
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
        return new { root = res, a= new {lol=res} };
    }
}

HeapDbg/lT

// Creates an array of un-aliased Data objects
class Data { int i; }
class Program {
    static object Run() {
        object res = { root = new Data[10] };
        for (int i = 0; i < res.Length; ++i)
            res.a[i] = new Data();
        return new { root = res };
    }
}

HeapDbg/9S

TI2LZ6  <a href="http://uugllgbfayvd.com/">uugllgbfayvd</a>, [url=http://gsdbjlinzjwr.com/]gsdbjlinzjwr[/url], [link=http://qtnjculuutee.com/]qtnjculuutee[/link], http://vfqmcwslknxp.com/

HeapDbg/PkI

// Create an tree containing nested arrays of speheres
// Everything is nested/unaliased but they all share a special color object
using System;
class Program {
    static object Run() {
        var special = new Color { red = 0, blue = 255, green = 0 };
        var rtn = STreeNode.MakeTree(3, special);
        return new { tree = rtn, scolor = special };
    }
}
class STreeNode {
    public STreeNode left; 
    public STreeNode right; 
    public Sphere[] data;

    public static STreeNode MakeTree(int k, Color c) {
        if (k == 0)
            return null;
        else {
            var sph = new Sphere[5];
            for (int i = 0; i < sph.Length; ++i) {
                var cp = new Point { xpos = k, ypos = k, zpos = k };
                sph[i] = new Sphere { center = cp, color = c, radius = 1F };
            }
            return new STreeNode { left = MakeTree(k - 1, c), right = MakeTree(k - 1, c), data = sph };
        }
    }
}
class Sphere { public Point center; public Color color; public float radius; }
class Color { public int red; public int blue; public int green; }
class Point { public float xpos; public float ypos; public float zpos; }

HeapDbg/lp

// Creates an array of un-aliased Data objects
class Etype { 
  
    public double value;
    public void setValue(double x)
    {
      value = x;
    }
}

class Add:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Sub:Etype{
  
  public Etype l;
  public Etype r;
  
}
class Mult:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Data{}
class Var:Etype{}
class Const:Etype{}


class Program {
    static object Run() {
        var res = new Data[10];
        
              
        Var []env = new Var[3];
        Const c = new Const();
        c.setValue(6);
        

        Sub sb  = new Sub();
        sb.r = env[0];
        sb.l = env[1];
        
        Add ad2 = new Add();
        ad2.l = env[1];
        ad2.r = c;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c;
        
        //Add exp = ad1;        
        
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
        return new { root = ad1 + env };
        
        
    }
}

HeapDbg/lnv

// Creates an array of un-aliased Data objects
class Data {public int i; }
class Program {
    static object Run() {
        var res = new Data[11];
        for (int i = 0; i < res.Length; ++i)
            {res[i] = new Data();res[i].i = i;}        res[10].i = 7829;
        return new { root = res };
    }
}

HeapDbg/Jk

// Create a LinkedList of Data objects
// Self edge on, Next, and label, List
class Data { }
class ListNode { public ListNode Next; public Data Data; }
class Program {
    static object Run() {
        ListNode res = null;
        for (int i = 0; i < 100; ++i)
            res = new ListNode { Next = res, Data = new Data() };
        return new { root = res };
    }
}

HeapDbg/zU

using System;

	public class Result { public Data[] array; public Data special;}

	public class Program
	{
		public static object Run()
		{
			Data[] resa = new Data[10];
			Data dspecial = new Data();

			for(int i = 0; i < 10; ++i)
			{
				if(i == 5)
					resa[i] = dspecial;
				else
					resa[i] = new Data();
			}

			return new Result { array = resa, special = dspecial };
		}
	}

	public class Data { public int val;}

HeapDbg/LM

// Creates an array of un-aliased Data objects
class Etype { 
  
    public double value;
    public void setValue(double x)
    {
      value = x;
    }
}

class Add:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Sub:Etype{
  
  public Etype l;
  public Etype r;
  
}
class Mult:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Data{}
class Var:Etype{}
class Const:Etype{}


class Program {
    static object Run() {
        var res = new Data[10];
        
              
        Var []env = new Var[3];
        Var v1 = null;
        Var v2 = null;
        
        env[0] = v1;
        env[0] = v2;
        
        Const c1 = new Const();
        Const c2 = new Const();
       
        

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        
        
        var exp = ad1;        
        
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
        return new { root = exp , variable = env };
        
        
    }
}

HeapDbg/wI

// Creates an array of un-aliased Data objects, some entries are null.
class Data { 
  public Dbtb other;
}
class Dbtb {
}
class Program {
    static object Run() {
        var res = new Data[10];
        for (int i = 0; i < 10; ++i) {
            if (i % 2 != 0 && i % 3 != 0) {
                res[i] = new Data();
                res[i].other = new Dbtb();
            }
        }
        return new { root = res };
    }
}

HeapDbg/CK

using System;

public class Program
	{
		public static object Run()
		{
			SceneObject[] things = new SceneObject[3];
			things[0] = new Sphere { Center = new Vector { X = -0.5F, Y = 1F, Z = 1.5F }, RGB = new Color { Red = 0, Blue = 255, Green = 0 }, Radius = 0.5F };
			things[1] = new Sphere { Center = new Vector { X = 0F, Y = 1F, Z = -0.25F }, RGB = new Color { Red = 0, Blue = 0, Green = 255 }, Radius = 1F };
			things[2] = new Plane { Norm = new Vector { X = 0F, Y = 1F, Z = 0F }, RGB = new Color { Red = 192, Blue = 192, Green = 192 }, Offset = 1F };


			Light[] lights = new Light[2];
			lights[0] = new Light { Pos = new Vector { X = -2F, Y = 2.5F, Z = 0F }, new Color { Red = 173, Blue = 216, Green = 230 } };
			lights[1] = new Light { Pos = new Vector { X = 2F, Y = 4.5F, Z = 2F }, new Color { Red = 255, Blue = 127, Green = 0 } };

			Camera camera = new Camera { Pos = new Vector { X = 2.75F, Y = 2F, Z = 3.75F }, Forward = new Vector { X = -0.6F, Y = 0.5F, Z = 0F } };

			return new Scene { Things = things, Lights = lights, Camera = camera };
		}
	}

	public class Scene { public SceneObject[] Things; public Light[] Lights; public Camera Camera; }
	
	public interface SceneObject { }
	public class Sphere : SceneObject { public Vector Center; public Color RGB; public float Radius; }
	public class Plane : SceneObject { public Vector Norm; public Color RGB; public float Offset; }

	public class Light { public Vector Pos; public Color RGB; }
	public class Camera { public Vector Pos; public Vector Forward; }

	public class Vector { public float X; public float Y; public float Z; }
	public class Color { public int Red; public int Blue; public int Green; }

HeapDbg/q

// Creates an array of un-aliased Data objects
class Data { } class Data2 { }
class Program {
    static object Run() {
        var res = new object[10];
        for (int i = 0; i < res.Length; ++i)
            res[i] = i % 2 == 0 ? (object)new Data2(): new object[1];
        return new { root = res };
    }
}

HeapDbg/9nc

// Creates an array of un-aliased Data objects
class Data { int a,b,c; }
class Program {
    static object Run() {
        var res = new Data[,10];
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data[10];
        return new { root = res };
    }
}

HeapDbg/g3

// Creates an array of un-aliased Data objects
class Data { }
class Program {
    static object Run() {
        var res = new Data[10];
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
        return new { root == res };
    }
}

HeapDbg/g2

// Creates an array of un-aliased Data objects
class Data { private int prop; }
class Program {
    static object Run() {
        var res = new Data[10];
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
        return new { root = res };
    }
}

HeapDbg/GJ

Using Spec# complete the implementation of the Stack class below and verify it using Spec#. Include methods with the following prototypes:
public void Push(int e); //add the integer e to the stack
public int Pop(); // removes the topmost element from the stack and returns the element that was removed.
[Pure] public bool IsEmpty(); //checks to see if the Stack is empty
[Pure] public bool IsFull(); //checks to see if the Stack is full
The code we completed in class follows:
using System;
using Microsoft.Contracts;
class Stack
{
[Rep] int[]! elements = new int[10];
int top;
invariant -1 <= top && top <= elements.Length;

public int Top {
get { return top; }
}

public int Capacity {
get
ensures result == elements.Length;
{ return elements.Length; }
}

[NotDelayed] public Stack()
ensures Top == -1;
ensures Capacity == 10;
{
top = -1;
}

public void Push(int e)
requires Top < Capacity - 1;
modifies this.*;
ensures Top == old(Top)+1;
ensures Capacity == old(Capacity);
ensures elements[top] == e;
{
expose (this) {
top ++; elements[top] = e;
}
}
}

HeapDbg/Zi

// Creates an array of un-aliased Data objects, some entries are null.
class Data { }
class Program {
    static object Run() {
        var res = new Data[10];
        for (int i = 0; i < 10; ++i) {
            if (i % 2 != 0 && i % 3 != 0)
                res[i] = new Data();
        }
        return new { root = res,lol=res };
    }
}

HeapDbg/fw

// Creates an array of un-aliased Data objects
class Data { }
class Program {
    static object Run() {
        var res = new Data[100];
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
        return new { root = res, ф= "" };
    }
}

HeapDbg/fUf

// Creates a Tree of Data objects
class Data { }
class TreeNode {
    public TreeNode Left;  public TreeNode Right; 
    public Data Data;
    public static TreeNode MakeTree(int k) {
        if (k <= 0)
            return null;
        else
            return new TreeNode { 
                Left = MakeTree(k - 1), 
                Right = MakeTree(k - 1), 
                Data = new Data() 
            };
    }
}
class Program {
    static object Run() {
        return new { root = TreeNode.MakeTree(7) };
    }
}

HeapDbg/Fu

// Create a LinkedList of Data objects
// Self edge on, Next, and label, List
class Data { }
class ListNode { public ListNode Next; public ListNode Tail; public Data Data; }
class Program {
    static object Run() {
        ListNode tail = new ListNode { Next=null, Tail=tail, Data=new Data() };
        ListNode res = tail;
        for (int i = 0; i < 10; ++i)
            res = new ListNode { Next = res, Tail = tail, Data = new Data() };
        return new { root = res };
    }
}

HeapDbg/Fs

class Eobjects{}
class Etype:Eobjects {public Etype pointsto;} 

class Add:Etype{ public Eobjects l; public Eobjects r; }
class Sub:Etype{ public Eobjects l; public Eobjects r; }
class Mult:Etype{ public Eobjects l; public Eobjects r; }

class Var:Eobjects{}  
class Const:Eobjects{}


class Program {
  
    static Var env = new Var[3];
    
    static object test(Etype exp, Var [] env)
    {
      
      return new { exp , env };
    }
    static object Run() {
              
        Var []env = new Var[3];
        
        
        
        Var v1= new Var();
        Var v2= new Var();
        Var v3= new Var();
        
        env[0] = v1;
        env[1] = v2;
        Const c1 = new Const();
        Const c2 = new Const();
       
     

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
        Etype exp = new Etype();
        exp.pointsto = ad1;
        return new { exp , env };
        
     
       
    }
}

HeapDbg/fr

class Etype {} 

class Add:Etype{ public Etype l; public Etype r; }
class Sub:Etype{ public Etype l; public Etype r; }
class Mult:Etype{ public Etype l; public Etype r; }

class Var:Etype{}  
class Const:Etype{}


class Program {
    static object Run() {
              
        Var []env = new Var[3];
        
        Etype exp = new Etype();
        
        Var v1= new Var();
        Var v2= new Var();
        Var v3= new Var();
        
        env[0] = v1;
        env[1] = v2;
        Const c1 = new Const();
        Const c2 = new Const();
       
     

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
                
        exp = ad1;
        return new { exp , env };
        
        
    }
}

HeapDbg/Jg

/**
 * Ejemplo de envio de correo simple con JavaMail
 *
 * @author Chuidiang
 *
  */
class EnviarMail
{
    /**
     * main de prueba
     * @param args Se ignoran.
     */
	int main(String[] args)
    {
    	ArrayList elements = new ArrayList();
    	elements.add(new Element("rodrigo","ricardo","ana_julia"));
    	elements.add(new Element("joaquin","ricardo","ana_julia"));
    	elements.add(new Element("cristobal","gabriel","marcela"));
    	elements.add(new Element("agustin","gabriel","marcela"));
    	elements.add(new Element("micaela","gabriel","marcela"));
    	elements.add(new Element("gabriel","antonio","anabela"));
    	elements.add(new Element("ana_julia","antonio","anabela"));
    	elements.add(new Element("ricardo","ireneo","norma"));
    	elements.add(new Element("ireneo","ireneo","norma"));
    	elements.add(new Element("pablo","ireneo","norma"));
//    	elements.add(new Element("acid","fire","sulfur"));
//    	elements.add(new Element("acid_rain","acid","rain"));
//    	elements.add(new Element("ai","computer","life"));
//    	elements.add(new Element("alcohol","water","fire"));
//    	elements.add(new Element("alien","space","life"));
//    	elements.add(new Element("aluminum","metal","electricity"));
//    	elements.add(new Element("ape","human","wool"));
//    	elements.add(new Element("aquaman","fish","human"));
//    	elements.add(new Element("aquarium","glass","fish"));
//    	elements.add(new Element("arable_land","soil","tool"));
//    	elements.add(new Element("ash","fire","dust"));
//    	elements.add(new Element("ashtray","ash","glass"));
//    	elements.add(new Element("baby","human","sex"));
//    	elements.add(new Element("bacterium","swamp","life"));
//    	elements.add(new Element("bank","money","brick_house"));
//    	elements.add(new Element("beach","water","sand"));
//    	elements.add(new Element("beast","soil","lizard"));
//    	elements.add(new Element("beer","alcohol","wheat"));
//    	elements.add(new Element("bird","air","egg"));
//    	elements.add(new Element("blood","hunter","bird"));
//    	elements.add(new Element("boat","water","wood"));
//    	elements.add(new Element("boiler","metal","steam"));
//    	elements.add(new Element("bomb","metal","gunpowder"));
//    	elements.add(new Element("bomber","plane","bomb"));
//    	elements.add(new Element("book","paper","feather"));
//    	elements.add(new Element("bread","fire","dough"));
//    	elements.add(new Element("brick","clay","fire"));
//    	elements.add(new Element("brick_house","concrete","brick"));
//    	elements.add(new Element("bug","soil","worm"));
//    	elements.add(new Element("bulb","electricity","glass"));
//    	elements.add(new Element("bungalow","hut","beach"));
//    	elements.add(new Element("business","money","human"));
//    	elements.add(new Element("butterfly","air","worm"));
//    	elements.add(new Element("cart","wood","wheel"));
//    	elements.add(new Element("caviar","fish","fish"));
//    	elements.add(new Element("cd","laser","book"));
//    	elements.add(new Element("cellphone","computer","radiowave"));
//    	elements.add(new Element("cement","clay","limestone"));
//    	elements.add(new Element("ceramics","clay","human"));
//    	elements.add(new Element("cigarette","paper","tobacco"));
//    	elements.add(new Element("clay","swamp","sand"));
//    	elements.add(new Element("cleaner","clobber","human"));
//    	elements.add(new Element("clobber","fabric","patient"));
//    	elements.add(new Element("clone","scientist","livestock"));
//    	elements.add(new Element("clothing","fabric","human"));
//    	elements.add(new Element("cloud","steam","air"));
//    	elements.add(new Element("coal","tree","fire"));
//    	elements.add(new Element("cockleshell","stone","plankton"));
//    	elements.add(new Element("coffee","seeds","energy"));
//    	elements.add(new Element("columbus","sailing_vessel","hero"));
//    	elements.add(new Element("computer","book","tv"));
//    	elements.add(new Element("concrete","water","cement"));
//    	elements.add(new Element("corpse","poison","human"));
//    	elements.add(new Element("cyborg","human","computer"));
//    	elements.add(new Element("developer","sex","computer"));
//    	elements.add(new Element("dinosaur","soil","egg"));
//    	elements.add(new Element("doctor","human","book"));
//    	elements.add(new Element("dough","water","flour"));
//    	elements.add(new Element("dragon","flying_dinosaur","fire"));
//    	elements.add(new Element("drinker","alcohol","human"));
//    	elements.add(new Element("dust","air","soil"));
//    	elements.add(new Element("egg","stone","life"));
//    	elements.add(new Element("electricity","scientist","energy"));
//    	elements.add(new Element("elixer","stone","philosopher"));
//    	elements.add(new Element("energy","air","fire"));
//    	elements.add(new Element("fabric","wool","tool"));
//    	elements.add(new Element("fart","peas","human"));
//    	elements.add(new Element("feather","bird","hunter"));
//    	elements.add(new Element("fern","swamp","moss"));
//    	elements.add(new Element("fire_golem","fire","life"));
//    	elements.add(new Element("firearms","weapon","gunpowder"));
//    	elements.add(new Element("fish","bacterium","plankton"));
//    	elements.add(new Element("flour","wheat","stone"));
//    	elements.add(new Element("flying_dinosaur","dinosaur","air"));
//    	elements.add(new Element("fried_egg","fire","egg"));
//    	elements.add(new Element("fried_meat","fire","meat"));
//    	elements.add(new Element("frog","fish","swamp"));
//    	elements.add(new Element("ghoul","zombie","corpse"));
//    	elements.add(new Element("glass","sand","fire"));
//    	elements.add(new Element("gold","elixer","any_other_element"));
//    	elements.add(new Element("golem","clay","life"));
//    	elements.add(new Element("grass","moss","soil"));
//    	elements.add(new Element("gunpowder","saltpeter","sulfur"));
//    	elements.add(new Element("hacker","pirate","internet"));
//    	elements.add(new Element("hero","warrior","dragon"));
//    	elements.add(new Element("hospital","brick_house","doctor"));
//    	elements.add(new Element("housemd","doctor","vicodin"));
//    	elements.add(new Element("human","golem","life"));
//    	elements.add(new Element("hunter","weapon","human"));
//    	elements.add(new Element("hut","stone","human"));
//    	elements.add(new Element("internet","computer","computer"));
//    	elements.add(new Element("japanese","human","rice"));
//    	elements.add(new Element("kamasutra","book","sex"));
//    	elements.add(new Element("katana","japanese","metal"));
//    	elements.add(new Element("lake","water","water"));
//    	elements.add(new Element("lamp","glass","fire"));
//    	elements.add(new Element("laser","radiowave","fire"));
//    	elements.add(new Element("lava","soil","fire"));
//    	elements.add(new Element("lava_golem","life","lava"));
//    	elements.add(new Element("life","energy","swamp"));
//    	elements.add(new Element("lighthouse","brick_house","lamp"));
//    	elements.add(new Element("limestone","stone","cockleshell"));
//    	elements.add(new Element("livestock","human","beast"));
//    	elements.add(new Element("lizard","snake","worm"));
//    	elements.add(new Element("manga","book","japanese"));
//    	elements.add(new Element("manure","livestock","grass"));
//    	elements.add(new Element("meat","hunter","bird"));
//    	elements.add(new Element("medicine","shaman","poison"));
//    	elements.add(new Element("mercury","fire","metal"));
//    	elements.add(new Element("metal","stone","fire"));
//    	elements.add(new Element("metal_golem","life","metal"));
//    	elements.add(new Element("meteorite","space","stone"));
//    	elements.add(new Element("milk","livestock","human"));
//    	elements.add(new Element("money","gold","paper"));
//    	elements.add(new Element("moss","swamp","seaweed"));
//    	elements.add(new Element("murderer","poison_weapon","human"));
//    	elements.add(new Element("mushroom","soil","seaweed"));
//    	elements.add(new Element("new_york","usa","skyscraper"));
//    	elements.add(new Element("ninja","samuri","poison_weapon"));
//    	elements.add(new Element("nuclearbomb","scientist","bomb"));
//    	elements.add(new Element("ocean","sea","sea"));
//    	elements.add(new Element("oil","water","coal"));
//    	elements.add(new Element("paper","tool","reed"));
//    	elements.add(new Element("patient","bacterium","human"));
//    	elements.add(new Element("peas","arable_land","seeds"));
//    	elements.add(new Element("petrol","oil","tool"));
//    	elements.add(new Element("phantom","nuclearbomb","anything"));
//    	elements.add(new Element("philosopher","grass","scientist"));
//    	elements.add(new Element("phoenix","fire","bird"));
//    	elements.add(new Element("pig-iron","metal","coal"));
//    	elements.add(new Element("pilot","plane","human"));
//    	elements.add(new Element("pirate","murderer","sailing_vessel"));
//    	elements.add(new Element("plane","bird","aluminum"));
//    	elements.add(new Element("plankton","water","bacterium"));
//    	elements.add(new Element("poison","tool","scorpion"));
//    	elements.add(new Element("poison_weapon","poison","weapon"));
//    	elements.add(new Element("pub","beer","brick_house"));
//    	elements.add(new Element("radiation","nuclearbomb","anything"));
//    	elements.add(new Element("radiowave","metal","energy"));
//    	elements.add(new Element("rain","cloud","water"));
//    	elements.add(new Element("reed","swamp","grass"));
//    	elements.add(new Element("rice","arable_land","reed"));
//    	elements.add(new Element("robot","japanese","tool"));
//    	elements.add(new Element("rocket","plane","gunpowder"));
//    	elements.add(new Element("rust","water","metal"));
//    	elements.add(new Element("sailing_boat","boat","fabric"));
//    	elements.add(new Element("sailing_vessel","wooden_ship","fabric"));
//    	elements.add(new Element("salt","metal","acid"));
//    	elements.add(new Element("saltpeter","manure","limestone"));
//    	elements.add(new Element("samurai","japanese","weapon"));
//    	elements.add(new Element("sand","water","stone"));
//    	elements.add(new Element("scientist","doctor","book"));
//    	elements.add(new Element("scorpion","bug","sand"));
//    	elements.add(new Element("sea","lake","salt"));
//    	elements.add(new Element("seaweed","life","water"));
//    	elements.add(new Element("seeds","life","sand"));
//    	elements.add(new Element("sex","human","human"));
//    	elements.add(new Element("shaman","mushroom","human"));
//    	elements.add(new Element("shop","clothing","brickhouse"));
//    	elements.add(new Element("skydiver","clobber","pilot"));
//    	elements.add(new Element("skyscraper","brickhouse","glass"));
//    	elements.add(new Element("snake","sand","worm"));
//    	elements.add(new Element("sniper","firearms","murderer"));
//    	elements.add(new Element("space","ocean","air"));
//    	elements.add(new Element("speedboat","boat","rocket"));
//    	elements.add(new Element("starwars","laser","weapon"));
//    	elements.add(new Element("steam","water","air"));
//    	elements.add(new Element("steam_engine","boiler","coal"));
//    	elements.add(new Element("steam_locomotive","steam_engine","cart"));
//    	elements.add(new Element("steamship","wooden_ship","steam_engine"));
//    	elements.add(new Element("stone","water","lava"));
//    	elements.add(new Element("storm","energy","air"));
//    	elements.add(new Element("submarine","whale","metal"));
//    	elements.add(new Element("submariner","submarine","human"));
//    	elements.add(new Element("sulfur","swamp","bacterium"));
//    	elements.add(new Element("sun","lava","space"));
//    	elements.add(new Element("swamp","water","soil"));
//    	elements.add(new Element("team","cart","beast"));
//    	elements.add(new Element("terrorist","bomb","murderer"));
//    	elements.add(new Element("thunderbird","storm","bird"));
//    	elements.add(new Element("tobacco","fire","grass"));
//    	elements.add(new Element("tool","human","metal"));
//    	elements.add(new Element("torpedo","rocket","water"));
//    	elements.add(new Element("toy","baby","anything"));
//    	elements.add(new Element("tree","soil","seeds"));
//    	elements.add(new Element("turtle","egg","sand"));
//    	elements.add(new Element("tv","radiowave","bulb"));
//    	elements.add(new Element("ufo","alien","rocket"));
//    	elements.add(new Element("usa","columbus","ocean"));
//    	elements.add(new Element("vampire","human","blood"));
//    	elements.add(new Element("vicodin","medicine","medicine"));
//    	elements.add(new Element("vodka","water","alcohol"));
//    	elements.add(new Element("walking_tree","life","tree"));
//    	elements.add(new Element("war","warrior","warrior"));
//    	elements.add(new Element("werewolf","vampire","beast"));
//    	elements.add(new Element("warrior","weapon","hunter"));
//    	elements.add(new Element("warship","wooden_ship","weapon"));
//    	elements.add(new Element("weapon","tool","metal"));
//    	elements.add(new Element("whale","fish","plankton"));
//    	elements.add(new Element("wheat","arable_land","grass"));
//    	elements.add(new Element("wheel","wood","tool"));
//    	elements.add(new Element("wood","tree","tool"));
//    	elements.add(new Element("wooden_ship","wood","boat"));
//    	elements.add(new Element("wool","beast","hunter"));
//    	elements.add(new Element("worm","bacterium","swamp"));
//    	elements.add(new Element("yogurt","milk","bacterium"));
//    	elements.add(new Element("zombie","life","corpse"));

//    	elements.add(new Element("soil","basic element"));
//    	elements.add(new Element("air","basic element"));
//    	elements.add(new Element("fire","basic element"));
//    	elements.add(new Element("water","basic element"));

    	HashMap parents = new HashMap();
    	for (int i = 0 ; i < elements.size(); i++){
    		Element element = (Element) elements.get(i);
    		if ( parents.containsKey(element.getFather()) ) {
    			Parent parent = (Parent) parents.get(element.getFather());
    			parent.addChild(element.getName());
    		} else {
    			parents.put(element.getFather(), new Parent( element.getFather(), element.getName()));
    		};
    		if ( parents.containsKey(element.getMother()) ) {
    			Parent parent = (Parent) parents.get(element.getMother());
    			parent.addChild(element.getName());
    		} else {
    			parents.put(element.getMother(), new Parent( element.getMother(), element.getName()));
    		};
    	}
    	
    	Collection parentsSimple = parents.values();
    	Iterator iterParent = parentsSimple.iterator();
//    	for (int i = 0 ; i < elements.size(); i++){
////    		if (((Element) elements.get(i)).getName().equals("housemd")){
//    		if (!( parents.containsKey(((Element) elements.get(i)).getName()))){
//        		System.out.println("digraph " + i + " {");
//        		drawAscendenceForElements((Element) elements.get(i), (ArrayList) elements.clone());
//        		System.out.println("}\n");
//    		}
//    	}
    	// drawing complete
    	System.out.println("digraph g {");
    	while (iterParent.hasNext()){
    		Parent parent = (Parent) (iterParent.next());
    		Object[] childs = parent.getChilds();
			for (int j = 0; j < childs.length; j++) {
				System.out.println(parent.getName() + " -> " + (String) childs[j]);
			}
    	}
    	System.out.println("}\n");
    	
    	/**
        try
        {
            // Propiedades de la conexión
            Properties props = new Properties();
            props.setProperty("mail.smtp.host", "smtp.gmail.com");
            props.setProperty("mail.smtp.starttls.enable", "true");
            props.setProperty("mail.smtp.port", "587");
            props.setProperty("mail.smtp.user", "rodrigo.peti@gmail.com");
            props.setProperty("mail.smtp.auth", "true");
            // Preparamos la sesion
            Session session = Session.getDefaultInstance(props);

            // Construimos el mensaje
            MimeMessage message = new MimeMessage(session);
            message.setFrom(new InternetAddress("rodrigo.peti@gmail.com"));
            message.addRecipient(
                    Message.RecipientType.TO,
                    new InternetAddress("rmolina@intelap.com"));
            message.setText(
                "Mensajito con Java Mail" + " de los buenos." + "poque si" + " funciona papa! ");

            // Lo enviamos.
            Transport t = session.getTransport("smtp");
            t.connect("smtp.gmail.com", "rodrigo.peti@gmail.com", "rodrorodro");
//            t.connect("rodrigo.peti@gmail.com", "rodrorodro");
            t.sendMessage(message, message.getAllRecipients());

            // Cierre.
            t.close();
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        */
    }

	private static void drawAscendenceForElements(Element element,
			ArrayList anotherElements) {
		if (element!=null){
			Element father = getElement( element.getFather(), anotherElements); 
			anotherElements.remove(father);
			Element mother = getElement( element.getMother(), anotherElements);
			anotherElements.remove(mother);
			drawAscendenceForElements(father, anotherElements);
			drawAscendenceForElements(mother, anotherElements);
			System.out.println( element.getFather() + " -> " + element.getName());
			System.out.println( element.getMother() + " -> " + element.getName());
		}
		
	}

	private static Element getElement(String parent, ArrayList anotherElements) {
		for (int i = 0; i < anotherElements.size(); i++){
			Element element = (Element) anotherElements.get(i);
			if (element.getName().equals(parent)){
				return element;
			}
		}
		return null;
	}
}

HeapDbg/fqs

// Creates an array of un-aliased Data objects
class Etype { 
  
    public double value;
    public void setValue(double x)
    {
      value = x;
    }
    public double getValue()
    {
      return value;
    }
  }

class Add:Etype{
  
  Etype l;
  Etype r;
  double getVal()
  {
    return (l.getValue()+r.getValue());    
  }
}

class Data{}
class Var:Etype{
   
}

class Const:Etype{
   
}


class Program {
    static object Run() {
        var res = new Data[10];
        
        Var []env = new Var[3];
        Const c1 = new Const;
        Const c2 = new Const;
        c1.setValue(5);
        c1.setValue(6);
        
        
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
        return new { root = res };
        
        
    }
}

HeapDbg/eea

HeapDbg/0U

// Creates an array of un-aliased Data objects, some entries are null.
class Data { 
  int x;
}
class Program {
    static object Run() {
        var res = new Data[10];
        for (int i = 0; i < 10; ++i) {
            if (i % 2 != 0 && i % 3 != 0) {
                res[i].x = 111;
                res[i] = new Data();
            }
        }
        return new { root = res };
    }
}

HeapDbg/eB

// Creates an array of un-aliased Data objects
class Data { int val; Data left; Data right; }
class Program {
    static object Run() {
        var res = new Data[10];
        for (int i = 0; i < res.Length; ++i)
            var d=new Data();  
            d.left=new Data();
            res[i] = d;
        return new { root = res };
    }
}

HeapDbg/E7

To think, I was confused a miunte ago.

HeapDbg/e56

// Creates a heap and returns each root as a field of the return object
class Hello { public World World; 

              public int getId()
              {
                
                return 100;
              }
}
class World { }

class Program {
    static object Run() {
      
        int id;
        id = 
        var res = new Hello { World = new World() };
        id = res.getId();
        return new { root = res };
    }
}

HeapDbg/E4

class Eobjects{}
class Etype:Eobjects {public Etype pointsto;} 

class Add:Etype{ public Eobjects l; public Eobjects r; }
class Sub:Etype{ public Eobjects l; public Eobjects r; }
class Mult:Etype{ public Eobjects l; public Eobjects r; }

class Var:Eobjects{}  
class Const:Eobjects{}


class Program {
    static object Run() {
              
        Var []env = new Var[3];
        
        
        
        Var v1= new Var();
        Var v2= new Var();
        Var v3= new Var();
        
        env[0] = v1;
        env[1] = v2;
        Const c1 = new Const();
        Const c2 = new Const();
       
     

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
        Etype exp = new Etype();
        exp = ad1;
        return new { exp , env };
        
        
    }
}

HeapDbg/o6

// Create an array of aliased Data objects
// Alising is shown as XXX color on [?] edge.
class Data { public int Value; }
class Program {
    static object Run() {
        var res = new Data[10];
        for (int i = 0; i < res.Length; ++i) {
            if (i % 2 == 0)
                res[i] = new Data();
            else
                res[i] = res[i - 1];
        }
        return new { root = res };
    }
}

HeapDbg/Bx

// Creates an array of un-aliased Data objects
class Data { }
class Program {
    static object Run() {
        var i = 5;
return {root = i};
    }
}

HeapDbg/Bv

// Creates an array of un-aliased Data objects
class Etype { 
  
    public double value;
    public void setValue(double x)
    {
      value = x;
    }
}

class Add:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Sub:Etype{
  
  public Etype l;
  public Etype r;
  
}
class Mult:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Data{}
class Var:Etype{}
class Const:Etype{}


class Program {
    static object Run() {
        var res = new Data[10];
        
              
        Var []env = new Var[3];
        Const c1 = new Const();
        Const c2 = new Const();
        c1.setValue(5);
        c1.setValue(6);
        

        Sub sb  = new Sub();
        sb.l = env[0];
        sb.l = env[1];
        
        Add ad2 = new Add();
        ad2.l = env[1];
        ad2.r = c2;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c1;
        
        var exp = ad1;        
        
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
        return new { root = exp,env };
        
        
    }
}

HeapDbg/Zc

using System;

public class Program
	{
		public static object Run()
		{
			SceneObject[] things = new SceneObject[3];
			things[0] = new Sphere { Center = new Vector { X = -0.5F, Y = 1F, Z = 1.5F }, RGB = new Color { Red = 0, Blue = 255, Green = 0 }, Radius = 0.5F };
			things[1] = new Sphere { Center = new Vector { X = 0F, Y = 1F, Z = -0.25F }, RGB = new Color { Red = 0, Blue = 0, Green = 255 }, Radius = 1F };
			things[2] = new Plane { Norm = new Vector { X = 0F, Y = 1F, Z = 0F }, RGB = new Color { Red = 192, Blue = 192, Green = 192 }, Offset = 1F };


			Light[] lights = new Light[2];
lights[0] = new Light { Pos = new Vector { X = -2F, Y = 2.5F, Z = 0F }, RGB = new Color { Red = 173, Blue = 216, Green = 230 } };
			lights[1] = new Light { Pos = new Vector { X = 2F, Y = 4.5F, Z = 2F }, RGB = new Color { Red = 255, Blue = 127, Green = 0 } };

			
			Camera camera = new Camera { Pos = new Vector { X = 2.75F, Y = 2F, Z = 3.75F }, Forward = new Vector { X = -0.6F, Y = 0.5F, Z = 0F } };

			return new Scene { Things = things, Lights = lights, Camera = camera };
		}
	}

	public class Scene { public SceneObject[] Things; public Light[] Lights; public Camera Camera; }
	
	public interface SceneObject { }
	public class Sphere : SceneObject { public Vector Center; public Color RGB; public float Radius; }
	public class Plane : SceneObject { public Vector Norm; public Color RGB; public float Offset; }

	public class Light { public Vector Pos; public Color RGB; }
	public class Camera { public Vector Pos; public Vector Forward; }

	public class Vector { public float X; public float Y; public float Z; }
	public class Color { public int Red; public int Blue; public int Green; }

HeapDbg/C0

Y6lbAh  <a href="http://uobvqagvewgk.com/">uobvqagvewgk</a>, [url=http://okszqnsnrisf.com/]okszqnsnrisf[/url], [link=http://wgbzwyintzvj.com/]wgbzwyintzvj[/link], http://yigdlfxradzy.com/

HeapDbg/cZ

// Creates an array of un-aliased Data objects
class Data { int a,b,c; }
class Program {
    static object Run() {
        var res = new Data[10,10];
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data[10];
        return new { root = res };
    }
}

HeapDbg/AN

// Creates an array of un-aliased Data objects
class Data { }
class Program {
    static object Run() {
        var res = new Data[10];
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
        return new { root = res };
    
}

HeapDbg/sH

// Create an array of un-aliased Shperes.
// Each a composite object of an unaliased Point object and Color object
class Color { public int red; public int blue; public int green; }
class Point { public float xpos; public float ypos; public float zpos; }
class Sphere { 
    public Point center; 
    public Color color; 
    public float radius; 
}
class Program {
    static object Run() {
        var spheres = new Sphere[10];
        for (int i = 0; i < spheres.Length; ++i) {
            var ctr = new Point { xpos = i, ypos = i + 1, zpos = i - 1 };
            var rgb = new Color { red = i, blue = i, green = i };
            spheres[i] = new Sphere { center = ctr, color = rgb, radius = 3.0F };
        }
        return new { spheres = spheres };
    }
}

HeapDbg/bN

// Create an array of un-aliased Data objects and one special object
class Data { public int val;}
class Program {
    static object Run() {
        var resa = new Data[10];
        var dspecial = new Data();
        for (int i = 0; i < resa.Length; ++i) {
            if (i == 5)
                resa[i] = dspecial;
            else
                resa[i] = new Data();
        }
        return new { array = resa, special = dspecial };
    }
}

HeapDbg/Ns

using System;

//Create a Deep Copy of a Tree of Data objects
namespace TreeCopyDeep
{
	public class Result { public TreeNode orig; public TreeNode copy;}

	public class Program
	{
		public static object Run() //<------------------------------------- RunShowMultiRoots()
		{
			TreeNode torig = TreeNode.MakeTree(3);
			TreeNode tcopy = TreeNode.CopyTreeDeep(torig);

			return new Result { orig = torig, copy = tcopy };
		}
	}

	public class TreeNode
	{
		public TreeNode left; public TreeNode right; public Data data;

		public static TreeNode MakeTree(int k)
		{
			if(k == 0)
				return null;
			else
				return new TreeNode { left = MakeTree(k - 1), right = MakeTree(k - 1), data = new Data() };
		}

		public static TreeNode CopyTreeDeep(TreeNode t)
		{
			if(t == null)
				return null;
			else
			{
				Data d = new Data { data = t.data };
				return new TreeNode { left = CopyTreeDeep(t.left), right = CopyTreeDeep(t.right), data = d };
			}
		}
	}

	public class Data { public int val;}
}

HeapDbg/plq

// Creates an array of un-aliased Data objects
class Data { }
class Program {
    static object Run() {
        var res = new Data[10];
        fo

HeapDbg/QW

IR94Q1  <a href="http://vmhykrcrftuy.com/">vmhykrcrftuy</a>, [url=http://aigravwqywgs.com/]aigravwqywgs[/url], [link=http://uiydjvmwvmjs.com/]uiydjvmwvmjs[/link], http://lwvmbmdporll.com/

HeapDbg/jBs

//Create an array of un-aliased and aliased Shperes.
// Each a composite object of an unaliased Point object but a shared Color object.
class Program {
    static object Run() {
        var spheres = new Sphere[10];
        var rgb = new Color { red = 0, blue = 255, green = 0 };
                return new { root = spheres };
    }
}
class Sphere { public Point center; public Color color; public float radius; }
class Color { public int red; public int blue; public int green; }
class Point { public float xpos; public float ypos; public float zpos; }

HeapDbg/5Kk

// Create an array of un-aliased Data objects and one special object
class Data { public int val;}
class SpecialData: Data {}
class Program {
    static object Run() {
        var resa = new Data[10];
        var dspecial = new SpecialData();
        for (int i = 0; i < resa.Length; ++i) {
            if (i == 5)
                resa[i] = dspecial;
            else
                resa[i] = new Data();
        }
        return new { array = resa, special = dspecial };
    }
}

HeapDbg/NP

// Creates an array of un-aliased Data objects
class Foo {}
class Data { Foo foo = new Foo(); }
class Program {
    static object Run() {
        var res = new Data[10];
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
        return new { root = res };
    }
}

HeapDbg/BR

using System;

public class Program
	{
		public static object Run()
		{
			SceneObject[] things = new SceneObject[3];
			things[0] = new Sphere { Center = new Vector { X = -0.5F, Y = 1F, Z = 1.5F }, RGB = new Color { Red = 0, Blue = 255, Green = 0 }, Radius = 0.5F };
			things[1] = new Sphere { Center = new Vector { X = 0F, Y = 1F, Z = -0.25F }, RGB = new Color { Red = 0, Blue = 0, Green = 255 }, Radius = 1F };
			things[2] = new Plane { Norm = new Vector { X = 0F, Y = 1F, Z = 0F }, RGB = new Color { Red = 192, Blue = 192, Green = 192 }, Offset = 1F };


			Light[] lights = new Light[2];
			
			Camera camera = new Camera { Pos = new Vector { X = 2.75F, Y = 2F, Z = 3.75F }, Forward = new Vector { X = -0.6F, Y = 0.5F, Z = 0F } };

			return new Scene { Things = things, Lights = lights, Camera = camera };
		}
	}

	public class Scene { public SceneObject[] Things; public Light[] Lights; public Camera Camera; }
	
	public interface SceneObject { }
	public class Sphere : SceneObject { public Vector Center; public Color RGB; public float Radius; }
	public class Plane : SceneObject { public Vector Norm; public Color RGB; public float Offset; }

	public class Light { public Vector Pos; public Color RGB; }
	public class Camera { public Vector Pos; public Vector Forward; }

	public class Vector { public float X; public float Y; public float Z; }
	public class Color { public int Red; public int Blue; public int Green; }

HeapDbg/1l

using System;

//Create a Deep Copy of a Tree of Data objects
namespace TreeCopyDeep
{
	public class Result { public TreeNode orig; public TreeNode copy;}

	public class Program
	{
		public static object Run() //<------------------------------------- RunShowMultiRoots()
		{
			TreeNode torig = TreeNode.MakeTree(3);
			TreeNode tcopy = TreeNode.CopyTreeShallow(torig);

			return new Result { orig = torig, copy = tcopy };
		}
	}

	public class TreeNode
	{
		public TreeNode left; public TreeNode right; public Data data;

		public static TreeNode MakeTree(int k)
		{
			if(k == 0)
				return null;
			else
				return new TreeNode { left = MakeTree(k - 1), right = MakeTree(k - 1), data = new Data() };
		}

		public static TreeNode CopyTreeDeep(TreeNode t)
		{
			if(t == null)
				return null;
			else
				return new TreeNode { left = CopyTreeDeep(t.left), right = CopyTreeDeep(t.right), data = new Data { data = t.data } };
		}
	}

	public class Data { public int val;}
}

HeapDbg/1I

Could not find sample or program sph

HeapDbg/mT

// Creates an array of un-aliased Data objects
class Data { int a,b,c; }
class Program {
    static object Run() {
        var res = new Data[][10];
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data[10];
        return new { root = res };
    }
}

HeapDbg/0P

// Creates an array of un-aliased Data objects
class Data2 { }
class Program {
    static object Run() {
        var res = new Data2[10];
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data2();
        return new { root = res };
    }
}

HeapDbg/ZV

// Creates an array of un-aliased Data objects
class Data {
  
  public  string getDeviceID()
  {
    return "123456";
  }
 }
 
 class Test
 {
   
   public void print(string s)
   {
     
     string d = s;
   }
   
 }
 
class Program {
    static object Run() {
        var res = new Data();
        var ob = new Test();
        //for (int i = 0; i < res.Length; ++i)
        string s = res.getDeviceID();
           
        ob.print(s);   
        return new { root = res };
    }
}

HeapDbg/zS

class Eobjects{}
class Etype:Eobjects {public Etype pointsto;} 

class Add:Etype{ public Eobjects l; public Eobjects r; }
class Sub:Etype{ public Eobjects l; public Eobjects r; }
class Mult:Etype{ public Eobjects l; public Eobjects r; }

class Var:Eobjects{}  
class Const:Eobjects{}


class Program {
    static object Run() {
              
        Var []env = new Var[3];
        
        
        
        Var v1= new Var();
        Var v2= new Var();
        Var v3= new Var();
        
        env[0] = v1;
        env[1] = v2;
        Const c1 = new Const();
        Const c2 = new Const();
       
     

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
        Add exp = new Add();
        exp.l = ad1;
        return new { exp , env };
        
        
    }
}

HeapDbg/zr

// Creates an array of un-aliased Data objects, some entries are null.
class Data { string t="ddada"; }
class Program {
    static object Run() {
        var res = new Data[10];
        for (int i = 0; i < 10; ++i) {
            if (i % 2 != 0 && i % 3 != 0)
                res[i] = new Data();
        }
        return new { root = res,lol=res };
    }
}

HeapDbg/zNT

// Create a scene structure for a simple raytracer
class Program {
    static object Run() {
        ISceneObject[] things = {
            new Sphere { 
                Center = new Vector { X = -0.5F, Y = 1F, Z = 1.5F }, 
                RGB = new Color { Red = 0, Blue = 255, Green = 0 }, 
                Radius = 0.5F },
            new Sphere { 
                Center = new Vector { X = 0F, Y = 1F, Z = -0.25F }, 
                RGB = new Color { Red = 0, Blue = 0, Green = 255 }, 
                Radius = 1F },
            new Plane { 
                Norm = new Vector { X = 0F, Y = 1F, Z = 0F }, 
                RGB = new Color { Red = 192, Blue = 192, Green = 192 }, 
                Offset = 1F }
        };

        Light[] lights = {
            new Light { 
                Pos = new Vector { X = -2F, Y = 2.5F, Z = 0F }, 
                RGB = new Color { Red = 173, Blue = 216, Green = 230 } },
            new Light { 
                Pos = new Vector { X = 2F, Y = 4.5F, Z = 2F }, 
                RGB = new Color { Red = 255, Blue = 127, Green = 0 } }
        };

        var camera = new Camera { 
            Pos = new Vector { X = 2.75F, Y = 2F, Z = 3.75F }, 
            Forward = new Vector { X = -0.6F, Y = 0.5F, Z = 0F } 
        };

        return new { 
            root = new Scene { Things = things, Lights = lights, Camera = camera } 
        };
    }
}

class Scene {
    public ISceneObject[] Things; 
    public Light[] Lights; 
    public Camera Camera; 
}

interface ISceneObject { }
class Sphere : ISceneObject { public Vector Center; public Color RGB; public float Radius; }
class Plane : ISceneObject { public Vector Norm; public Color RGB; public float Offset; }

class Light { public Vector Pos; public Color RGB; }
class Camera { public Vector Pos; public Vector Forward; }

class Vector { public float X; public float Y; public float Z; }
class Color { public int Red; public int Blue; public int Green; }

HeapDbg/g6

// Creates a Tree of Data objects
class Data { }
class TreeNode {
    public TreeNode Left;  public TreeNode Right; 
    public Data Data;
    public static TreeNode MakeTree(int k) {
        if (k <= 0)
            return null;
        else
            return new TreeNode { 
                Left = MakeTree(k - 1), 
                Right = MakeTree(k - 1), 
                Data = new Data() 
            };
    }
}
class Program {
    static object Run() {
        return new { root = TreeNode.MakeTree(3) };
    }
}

HeapDbg/Dq

// Creates an array of un-aliased Data objects
class Data { } class Data2 { }
class Program {
    static object Run() {
        var res = new object[10];
        for (int i = 0; i < res.Length; ++i)
            res[i] = i % 2 == 0 ? (object)new Data2(): new System.Text.StringBuilder();
        return new { root = res };
    }
}

HeapDbg/Zm

// Creates a Deep Copy of a Tree of Data objects
class Data { public int Value;}
class TreeNode {
    public TreeNode Left; public TreeNode Right; 
    public Data Data;
    public static TreeNode MakeTree(int k) {
        if (k == 0)
            return null;
        else
            return new TreeNode { 
                Left = MakeTree(k - 1), Right = MakeTree(k - 1), 
                Data = new Data() 
            };
    }
    public static TreeNode CopyTreeDeep(TreeNode t) {
        if (t == null)
            return null;
        else
            return new TreeNode { 
                Left = CopyTreeDeep(t.Left), Right = CopyTreeDeep(t.Right), 
                Data = new Data { Value = t.Data.Value } 
            };
    }
}
class Program {
    static object Run() {
        var original = TreeNode.MakeTree(3);
        var copy = TreeNode.CopyTreeDeep(original);

        return new { orig = original, copy = copy };
    }
}

HeapDbg/zL

// Creates an array of un-aliased Data objects
class Data { int a,b,c; }
class Program {
    static object Run() {
        var res = new Data[10,10];
        for (int i = 0; i < res.Length; ++i)
            res[i,0] = new Data[10];
        return new { root = res };
    }
}

HeapDbg/zH

// Creates an array of un-aliased Data objects
class Data { 
  
  public string getDeviceID()
  {
       return "121";
  }
}


class Program {
    static void t() {
        string val;
        var res = new Data[10];
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
            
        val = res[0].getDeviceID();            
        //return new {root = res };
    }
}

HeapDbg/ud

using System;

public class Program
	{
		public static object Run()
		{
			SceneObject[] things = new SceneObject[3];
			things[0] = new Sphere { Center = new Vector { X = -0.5F, Y = 1F, Z = 1.5F }, RGB = new Color { Red = 0, Blue = 255, Green = 0 }, Radius = 0.5F };
			things[1] = new Sphere { Center = new Vector { X = 0F, Y = 1F, Z = -0.25F }, RGB = new Color { Red = 0, Blue = 0, Green = 255 }, Radius = 1F };
			things[2] = new Plane { Norm = new Vector { X = 0F, Y = 1F, Z = 0F }, RGB = new Color { Red = 192, Blue = 192, Green = 192 }, Offset = 1F };

			Light[] lights = new Light[2];
			lights[0] = new Light { Pos = new Vector { X = -2F, Y = 2.5F, Z = 0F }, new Color { Red = 173, Blue = 216, Green = 230 } };
			lights[1] = new Light { Pos = new Vector { X = 2F, Y = 4.5F, Z = 2F }, new Color { Red = 255, Blue = 127, Green = 0 } };

			Camera camera = new Camera { Pos = new Vector { X = 2.75F, Y = 2F, Z = 3.75F }, Forward = new Vector { X = -0.6F, Y = 0.5F, Z = 0F } };

			return new Scene { Things = things, Lights = lights, Camara = camera };
		}
	}

	public class Scene { public SceneObject[] Things; public Light[] Lights; public Camera Camera; }
	
	public interface SceneObject { }
	public class Sphere : SceneObject { public Vector Center; public Color RGB; public float Radius; }
	public class Plane : SceneObject { public Vector Norm; public Color RGB; public float Offset; }

	public class Light { public Vector Pos; public Color RGB; }
	public class Camera { public Vector Pos; public Vector Forward; }

	public class Vector { public float X; public float Y; public float Z; }
	public class Color { public int Red; public int Blue; public int Green; }

HeapDbg/zBb

Could not find sample or program smtc_arith

HeapDbg/zb

// Create a LinkedList of Data objects
// Self edge on, Next, and label, List
class Data { }
class ListNode { public ListNode Next; public Data Data; }
class Program {
    static object Run() {
        ListNode res = null;
        for (int i = 0; i < 10; ++i)
            res = new ListNode { Next = res, Data = new Data() };
        return new { root = res };
    }
}

HeapDbg/3

// Creates an array of un-aliased Data objects
class Data { } class Data2 { }
class Program {
    static object Run() {
        var res = new object[10];
        for (int i = 0; i < res.Length; ++i)
            res[i] = i % 2 == 0 ? (object)new Data2(): new Data();
        return new { root = res };
    }
}

HeapDbg/Z9

// Creates an array of un-aliased Data objects
class Data { }
class Program {
    static object Run() {
        var res = new Data[10];
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
        return res[1] ;
    }
}

HeapDbg/Z8

5LZuBb  <a href="http://npifuwprwtch.com/">npifuwprwtch</a>, [url=http://msvhewimsohl.com/]msvhewimsohl[/url], [link=http://barkgblzspjw.com/]barkgblzspjw[/link], http://mesrptumiusd.com/

HeapDbg/Ap

/**
 * Ejemplo de envio de correo simple con JavaMail
 *
 * @author Chuidiang
 *
  */
class EnviarMail
{
    /**
     * main de prueba
     * @param args Se ignoran.
     */
    @SuppressWarnings("unchecked")
	public int main(String[] args)
    {
    	ArrayList elements = new ArrayList();
    	elements.add(new Element("rodrigo","ricardo","ana_julia"));
    	elements.add(new Element("joaquin","ricardo","ana_julia"));
    	elements.add(new Element("cristobal","gabriel","marcela"));
    	elements.add(new Element("agustin","gabriel","marcela"));
    	elements.add(new Element("micaela","gabriel","marcela"));
    	elements.add(new Element("gabriel","antonio","anabela"));
    	elements.add(new Element("ana_julia","antonio","anabela"));
    	elements.add(new Element("ricardo","ireneo","norma"));
    	elements.add(new Element("ireneo","ireneo","norma"));
    	elements.add(new Element("pablo","ireneo","norma"));
//    	elements.add(new Element("acid","fire","sulfur"));
//    	elements.add(new Element("acid_rain","acid","rain"));
//    	elements.add(new Element("ai","computer","life"));
//    	elements.add(new Element("alcohol","water","fire"));
//    	elements.add(new Element("alien","space","life"));
//    	elements.add(new Element("aluminum","metal","electricity"));
//    	elements.add(new Element("ape","human","wool"));
//    	elements.add(new Element("aquaman","fish","human"));
//    	elements.add(new Element("aquarium","glass","fish"));
//    	elements.add(new Element("arable_land","soil","tool"));
//    	elements.add(new Element("ash","fire","dust"));
//    	elements.add(new Element("ashtray","ash","glass"));
//    	elements.add(new Element("baby","human","sex"));
//    	elements.add(new Element("bacterium","swamp","life"));
//    	elements.add(new Element("bank","money","brick_house"));
//    	elements.add(new Element("beach","water","sand"));
//    	elements.add(new Element("beast","soil","lizard"));
//    	elements.add(new Element("beer","alcohol","wheat"));
//    	elements.add(new Element("bird","air","egg"));
//    	elements.add(new Element("blood","hunter","bird"));
//    	elements.add(new Element("boat","water","wood"));
//    	elements.add(new Element("boiler","metal","steam"));
//    	elements.add(new Element("bomb","metal","gunpowder"));
//    	elements.add(new Element("bomber","plane","bomb"));
//    	elements.add(new Element("book","paper","feather"));
//    	elements.add(new Element("bread","fire","dough"));
//    	elements.add(new Element("brick","clay","fire"));
//    	elements.add(new Element("brick_house","concrete","brick"));
//    	elements.add(new Element("bug","soil","worm"));
//    	elements.add(new Element("bulb","electricity","glass"));
//    	elements.add(new Element("bungalow","hut","beach"));
//    	elements.add(new Element("business","money","human"));
//    	elements.add(new Element("butterfly","air","worm"));
//    	elements.add(new Element("cart","wood","wheel"));
//    	elements.add(new Element("caviar","fish","fish"));
//    	elements.add(new Element("cd","laser","book"));
//    	elements.add(new Element("cellphone","computer","radiowave"));
//    	elements.add(new Element("cement","clay","limestone"));
//    	elements.add(new Element("ceramics","clay","human"));
//    	elements.add(new Element("cigarette","paper","tobacco"));
//    	elements.add(new Element("clay","swamp","sand"));
//    	elements.add(new Element("cleaner","clobber","human"));
//    	elements.add(new Element("clobber","fabric","patient"));
//    	elements.add(new Element("clone","scientist","livestock"));
//    	elements.add(new Element("clothing","fabric","human"));
//    	elements.add(new Element("cloud","steam","air"));
//    	elements.add(new Element("coal","tree","fire"));
//    	elements.add(new Element("cockleshell","stone","plankton"));
//    	elements.add(new Element("coffee","seeds","energy"));
//    	elements.add(new Element("columbus","sailing_vessel","hero"));
//    	elements.add(new Element("computer","book","tv"));
//    	elements.add(new Element("concrete","water","cement"));
//    	elements.add(new Element("corpse","poison","human"));
//    	elements.add(new Element("cyborg","human","computer"));
//    	elements.add(new Element("developer","sex","computer"));
//    	elements.add(new Element("dinosaur","soil","egg"));
//    	elements.add(new Element("doctor","human","book"));
//    	elements.add(new Element("dough","water","flour"));
//    	elements.add(new Element("dragon","flying_dinosaur","fire"));
//    	elements.add(new Element("drinker","alcohol","human"));
//    	elements.add(new Element("dust","air","soil"));
//    	elements.add(new Element("egg","stone","life"));
//    	elements.add(new Element("electricity","scientist","energy"));
//    	elements.add(new Element("elixer","stone","philosopher"));
//    	elements.add(new Element("energy","air","fire"));
//    	elements.add(new Element("fabric","wool","tool"));
//    	elements.add(new Element("fart","peas","human"));
//    	elements.add(new Element("feather","bird","hunter"));
//    	elements.add(new Element("fern","swamp","moss"));
//    	elements.add(new Element("fire_golem","fire","life"));
//    	elements.add(new Element("firearms","weapon","gunpowder"));
//    	elements.add(new Element("fish","bacterium","plankton"));
//    	elements.add(new Element("flour","wheat","stone"));
//    	elements.add(new Element("flying_dinosaur","dinosaur","air"));
//    	elements.add(new Element("fried_egg","fire","egg"));
//    	elements.add(new Element("fried_meat","fire","meat"));
//    	elements.add(new Element("frog","fish","swamp"));
//    	elements.add(new Element("ghoul","zombie","corpse"));
//    	elements.add(new Element("glass","sand","fire"));
//    	elements.add(new Element("gold","elixer","any_other_element"));
//    	elements.add(new Element("golem","clay","life"));
//    	elements.add(new Element("grass","moss","soil"));
//    	elements.add(new Element("gunpowder","saltpeter","sulfur"));
//    	elements.add(new Element("hacker","pirate","internet"));
//    	elements.add(new Element("hero","warrior","dragon"));
//    	elements.add(new Element("hospital","brick_house","doctor"));
//    	elements.add(new Element("housemd","doctor","vicodin"));
//    	elements.add(new Element("human","golem","life"));
//    	elements.add(new Element("hunter","weapon","human"));
//    	elements.add(new Element("hut","stone","human"));
//    	elements.add(new Element("internet","computer","computer"));
//    	elements.add(new Element("japanese","human","rice"));
//    	elements.add(new Element("kamasutra","book","sex"));
//    	elements.add(new Element("katana","japanese","metal"));
//    	elements.add(new Element("lake","water","water"));
//    	elements.add(new Element("lamp","glass","fire"));
//    	elements.add(new Element("laser","radiowave","fire"));
//    	elements.add(new Element("lava","soil","fire"));
//    	elements.add(new Element("lava_golem","life","lava"));
//    	elements.add(new Element("life","energy","swamp"));
//    	elements.add(new Element("lighthouse","brick_house","lamp"));
//    	elements.add(new Element("limestone","stone","cockleshell"));
//    	elements.add(new Element("livestock","human","beast"));
//    	elements.add(new Element("lizard","snake","worm"));
//    	elements.add(new Element("manga","book","japanese"));
//    	elements.add(new Element("manure","livestock","grass"));
//    	elements.add(new Element("meat","hunter","bird"));
//    	elements.add(new Element("medicine","shaman","poison"));
//    	elements.add(new Element("mercury","fire","metal"));
//    	elements.add(new Element("metal","stone","fire"));
//    	elements.add(new Element("metal_golem","life","metal"));
//    	elements.add(new Element("meteorite","space","stone"));
//    	elements.add(new Element("milk","livestock","human"));
//    	elements.add(new Element("money","gold","paper"));
//    	elements.add(new Element("moss","swamp","seaweed"));
//    	elements.add(new Element("murderer","poison_weapon","human"));
//    	elements.add(new Element("mushroom","soil","seaweed"));
//    	elements.add(new Element("new_york","usa","skyscraper"));
//    	elements.add(new Element("ninja","samuri","poison_weapon"));
//    	elements.add(new Element("nuclearbomb","scientist","bomb"));
//    	elements.add(new Element("ocean","sea","sea"));
//    	elements.add(new Element("oil","water","coal"));
//    	elements.add(new Element("paper","tool","reed"));
//    	elements.add(new Element("patient","bacterium","human"));
//    	elements.add(new Element("peas","arable_land","seeds"));
//    	elements.add(new Element("petrol","oil","tool"));
//    	elements.add(new Element("phantom","nuclearbomb","anything"));
//    	elements.add(new Element("philosopher","grass","scientist"));
//    	elements.add(new Element("phoenix","fire","bird"));
//    	elements.add(new Element("pig-iron","metal","coal"));
//    	elements.add(new Element("pilot","plane","human"));
//    	elements.add(new Element("pirate","murderer","sailing_vessel"));
//    	elements.add(new Element("plane","bird","aluminum"));
//    	elements.add(new Element("plankton","water","bacterium"));
//    	elements.add(new Element("poison","tool","scorpion"));
//    	elements.add(new Element("poison_weapon","poison","weapon"));
//    	elements.add(new Element("pub","beer","brick_house"));
//    	elements.add(new Element("radiation","nuclearbomb","anything"));
//    	elements.add(new Element("radiowave","metal","energy"));
//    	elements.add(new Element("rain","cloud","water"));
//    	elements.add(new Element("reed","swamp","grass"));
//    	elements.add(new Element("rice","arable_land","reed"));
//    	elements.add(new Element("robot","japanese","tool"));
//    	elements.add(new Element("rocket","plane","gunpowder"));
//    	elements.add(new Element("rust","water","metal"));
//    	elements.add(new Element("sailing_boat","boat","fabric"));
//    	elements.add(new Element("sailing_vessel","wooden_ship","fabric"));
//    	elements.add(new Element("salt","metal","acid"));
//    	elements.add(new Element("saltpeter","manure","limestone"));
//    	elements.add(new Element("samurai","japanese","weapon"));
//    	elements.add(new Element("sand","water","stone"));
//    	elements.add(new Element("scientist","doctor","book"));
//    	elements.add(new Element("scorpion","bug","sand"));
//    	elements.add(new Element("sea","lake","salt"));
//    	elements.add(new Element("seaweed","life","water"));
//    	elements.add(new Element("seeds","life","sand"));
//    	elements.add(new Element("sex","human","human"));
//    	elements.add(new Element("shaman","mushroom","human"));
//    	elements.add(new Element("shop","clothing","brickhouse"));
//    	elements.add(new Element("skydiver","clobber","pilot"));
//    	elements.add(new Element("skyscraper","brickhouse","glass"));
//    	elements.add(new Element("snake","sand","worm"));
//    	elements.add(new Element("sniper","firearms","murderer"));
//    	elements.add(new Element("space","ocean","air"));
//    	elements.add(new Element("speedboat","boat","rocket"));
//    	elements.add(new Element("starwars","laser","weapon"));
//    	elements.add(new Element("steam","water","air"));
//    	elements.add(new Element("steam_engine","boiler","coal"));
//    	elements.add(new Element("steam_locomotive","steam_engine","cart"));
//    	elements.add(new Element("steamship","wooden_ship","steam_engine"));
//    	elements.add(new Element("stone","water","lava"));
//    	elements.add(new Element("storm","energy","air"));
//    	elements.add(new Element("submarine","whale","metal"));
//    	elements.add(new Element("submariner","submarine","human"));
//    	elements.add(new Element("sulfur","swamp","bacterium"));
//    	elements.add(new Element("sun","lava","space"));
//    	elements.add(new Element("swamp","water","soil"));
//    	elements.add(new Element("team","cart","beast"));
//    	elements.add(new Element("terrorist","bomb","murderer"));
//    	elements.add(new Element("thunderbird","storm","bird"));
//    	elements.add(new Element("tobacco","fire","grass"));
//    	elements.add(new Element("tool","human","metal"));
//    	elements.add(new Element("torpedo","rocket","water"));
//    	elements.add(new Element("toy","baby","anything"));
//    	elements.add(new Element("tree","soil","seeds"));
//    	elements.add(new Element("turtle","egg","sand"));
//    	elements.add(new Element("tv","radiowave","bulb"));
//    	elements.add(new Element("ufo","alien","rocket"));
//    	elements.add(new Element("usa","columbus","ocean"));
//    	elements.add(new Element("vampire","human","blood"));
//    	elements.add(new Element("vicodin","medicine","medicine"));
//    	elements.add(new Element("vodka","water","alcohol"));
//    	elements.add(new Element("walking_tree","life","tree"));
//    	elements.add(new Element("war","warrior","warrior"));
//    	elements.add(new Element("werewolf","vampire","beast"));
//    	elements.add(new Element("warrior","weapon","hunter"));
//    	elements.add(new Element("warship","wooden_ship","weapon"));
//    	elements.add(new Element("weapon","tool","metal"));
//    	elements.add(new Element("whale","fish","plankton"));
//    	elements.add(new Element("wheat","arable_land","grass"));
//    	elements.add(new Element("wheel","wood","tool"));
//    	elements.add(new Element("wood","tree","tool"));
//    	elements.add(new Element("wooden_ship","wood","boat"));
//    	elements.add(new Element("wool","beast","hunter"));
//    	elements.add(new Element("worm","bacterium","swamp"));
//    	elements.add(new Element("yogurt","milk","bacterium"));
//    	elements.add(new Element("zombie","life","corpse"));

//    	elements.add(new Element("soil","basic element"));
//    	elements.add(new Element("air","basic element"));
//    	elements.add(new Element("fire","basic element"));
//    	elements.add(new Element("water","basic element"));

    	HashMap parents = new HashMap();
    	for (int i = 0 ; i < elements.size(); i++){
    		Element element = (Element) elements.get(i);
    		if ( parents.containsKey(element.getFather()) ) {
    			Parent parent = (Parent) parents.get(element.getFather());
    			parent.addChild(element.getName());
    		} else {
    			parents.put(element.getFather(), new Parent( element.getFather(), element.getName()));
    		};
    		if ( parents.containsKey(element.getMother()) ) {
    			Parent parent = (Parent) parents.get(element.getMother());
    			parent.addChild(element.getName());
    		} else {
    			parents.put(element.getMother(), new Parent( element.getMother(), element.getName()));
    		};
    	}
    	
    	Collection parentsSimple = parents.values();
    	Iterator iterParent = parentsSimple.iterator();
//    	for (int i = 0 ; i < elements.size(); i++){
////    		if (((Element) elements.get(i)).getName().equals("housemd")){
//    		if (!( parents.containsKey(((Element) elements.get(i)).getName()))){
//        		System.out.println("digraph " + i + " {");
//        		drawAscendenceForElements((Element) elements.get(i), (ArrayList) elements.clone());
//        		System.out.println("}\n");
//    		}
//    	}
    	// drawing complete
    	System.out.println("digraph g {");
    	while (iterParent.hasNext()){
    		Parent parent = (Parent) (iterParent.next());
    		Object[] childs = parent.getChilds();
			for (int j = 0; j < childs.length; j++) {
				System.out.println(parent.getName() + " -> " + (String) childs[j]);
			}
    	}
    	System.out.println("}\n");
    	
    	/**
        try
        {
            // Propiedades de la conexión
            Properties props = new Properties();
            props.setProperty("mail.smtp.host", "smtp.gmail.com");
            props.setProperty("mail.smtp.starttls.enable", "true");
            props.setProperty("mail.smtp.port", "587");
            props.setProperty("mail.smtp.user", "rodrigo.peti@gmail.com");
            props.setProperty("mail.smtp.auth", "true");
            // Preparamos la sesion
            Session session = Session.getDefaultInstance(props);

            // Construimos el mensaje
            MimeMessage message = new MimeMessage(session);
            message.setFrom(new InternetAddress("rodrigo.peti@gmail.com"));
            message.addRecipient(
                    Message.RecipientType.TO,
                    new InternetAddress("rmolina@intelap.com"));
            message.setText(
                "Mensajito con Java Mail" + " de los buenos." + "poque si" + " funciona papa! ");

            // Lo enviamos.
            Transport t = session.getTransport("smtp");
            t.connect("smtp.gmail.com", "rodrigo.peti@gmail.com", "rodrorodro");
//            t.connect("rodrigo.peti@gmail.com", "rodrorodro");
            t.sendMessage(message, message.getAllRecipients());

            // Cierre.
            t.close();
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        */
    }

	private static void drawAscendenceForElements(Element element,
			ArrayList anotherElements) {
		if (element!=null){
			Element father = getElement( element.getFather(), anotherElements); 
			anotherElements.remove(father);
			Element mother = getElement( element.getMother(), anotherElements);
			anotherElements.remove(mother);
			drawAscendenceForElements(father, anotherElements);
			drawAscendenceForElements(mother, anotherElements);
			System.out.println( element.getFather() + " -> " + element.getName());
			System.out.println( element.getMother() + " -> " + element.getName());
		}
		
	}

	private static Element getElement(String parent, ArrayList anotherElements) {
		for (int i = 0; i < anotherElements.size(); i++){
			Element element = (Element) anotherElements.get(i);
			if (element.getName().equals(parent)){
				return element;
			}
		}
		return null;
	}
}

HeapDbg/z

using System;

public class Program
	{
		public static object Run()
		{
			Data[] res = new Data[10];

			for(int i = 0; i < 10; ++i)
			{
				if(i % 2 == 0)
					res[i] = new Data();
				else
					res[i] = res[i - 1];
			}

			return new Tuple<object, object>(res, new Data());
		}
	}

	public class Data { public int val;}

HeapDbg/Ae

// Creates an array of un-aliased Data objects, some entries are null.
class Data { Random t=new Random(); }
class Program {
    static object Run() {
        var res = new Data[10];
        for (int i = 0; i < 10; ++i) {
            if (i % 2 != 0 && i % 3 != 0)
                res[i] = new Data();
        }
        return new { root = res,lol=res };
    }
}

HeapDbg/sc

class Etype {} 

class Add:Etype{ public Etype l; public Etype r; }
class Sub:Etype{ public Etype l; public Etype r; }
class Mult:Etype{ public Etype l; public Etype r; }

class Var:Etype{}  
class Const:Etype{}


class Program {
    static object Run() {
              
        Var []env = new Var[3];
        object exp = new object;
        
        
        Var v1= new Var();
        Var v2= new Var();
        Var v3= new Var();
        
        env[0] = v1;
        env[1] = v2;
        Const c1 = new Const();
        Const c2 = new Const();
       
     

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
                
        exp = ad1;
        return new { exp , env };
        
        
    }
}

HeapDbg/sB

// Creates an array of un-aliased Data objects
class Data { }
class Program {
    static object Run() {
        var res = new Data[10];
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
        return new { res = res };
    }
}

HeapDbg/K5L

// Creates an array of un-aliased Data objects
class Data { int i; }
class Program {
    static object Run() {
        object res = new { a = new Data[10] };
        for (int i = 0; i < res.a.Length; ++i)
            res.a[i] = new Data();
        return new { root = res };
    }
}

HeapDbg/d

using System;

	public class Program
	{
		public static object Run()
		{
			Sphere[] spheres = new Sphere[10];

			for(int i = 0; i < 10; ++i)
			{
				Point ctr = new Point { xpos = i, ypos = i + 1, zpos = i - 1 };
				Color rgb = new Color { red = i, blue = i, green = i };				spheres[i] = new Sphere { center = ctr, color = rgb, radius = 3.0F };
			}

			return spheres;
		}
	}

	public class Sphere { public Point center; public Color color; public float radius; }
	public class Color { public int red; public int blue; public int green; }
	public class Point { public float xpos; public float ypos; public float zpos; }

HeapDbg/oQ

// Creates an array of un-aliased Data objects, some entries are null.
class Data { int Test; }
class Program {
    static object Run() {
        var res = new Data[10];
        for (int i = 0; i < 10; ++i) {
            if (i % 2 != 0 && i % 3 != 0)
                res[i] = new Data() { Test = i};
        }
        return new { root = res };
    }
}

HeapDbg/sy

// Creates a heap and returns each root as a field of the return object
class Hello { public World World; }
class World { }
class Program {
    static object Run() {
        var res = new Hello { World = new World() };
        return new { root = "" };
    }
}

HeapDbg/s

using System;

	public class Program
	{
		public static object Run()
		{
			Sphere[] spheres = new Sphere[10];

			for(int i = 0; i < 10; ++i)
			{
				Point ctr = new Point { xpos = i, ypos = i + 1, zpos = i - 1 };
				Color rgb = new Color { red = i, blue = i, green = i };				spheres[i] = new Sphere { center = ctr, color = rgb, radius = 3.0 };
			}

			return new Result { array = resa, special = dspecial };
		}
	}

	public class Sphere { public Point center; public Color color; public float radius; }
	public class Color { public int red; public int blue; public int green; }
	public class Point { public float xpos; public float ypos; public float zpos; }

HeapDbg/rz

// Creates an array of un-aliased Data objects
class Data { }
class Program {
    static object Run() {
        var res = new Data[10];
        for (int i = 0; i < res.Length; ++i)
            res[i+1] = new Data();
        return new { root = res };
    }
}

HeapDbg/Js

// Creates an array of un-aliased Data objects
class Data { }
class Program {
    static object Run() {
        var res = new Data[10];
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
        return new  (root);
    }
}

HeapDbg/Ry7

// Create a LinkedList of Data objects
// Self edge on, Next, and label, List
using System.Collection.Generic;
class Data { }
class Program {
    static object Run() {
        return "abc";
    }
}

HeapDbg/Ry

I found myself nodding my nggoin all the way through.

HeapDbg/bg

// Creates an array of un-aliased Data objects
class Data { }
class Program {
    static object Run() {
        var res = new Data[10];
        for (int i = 1; i < res.Length; ++i)
            res[i] = new Data();
        return new { root = res };
    }
}

HeapDbg/rW

// Creates an array of un-aliased Data objects
class Etype { 
  
    public double value;
    public void setValue(double x)
    {
      value = x;
    }
}

class Add:Etype{
  
  public Etype l;
  public Etype r;
  
  
}

class Sub:Etype{
  
  public Etype l;
  public Etype r;
  
}
class Mult:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Data{}
class Var:Etype{
  
  public Etype arrayIndex;
}
class Const:Etype{}


class Program {
    static object Run() {
              
        Var []env = new Var[3];
        
        Var v1 = new Var();
        Var v2 = new Var();
        
        env[0].arrayIndex = v1;
        env[1].arrayIndex = v2;
        
        Const c1 = new Const();
        Const c2 = new Const();
       
        

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
        var exp = ad1;        
        
        
        return new { root = exp , v = env };
        
        
    }
}

HeapDbg/RUc

// Creates an array of un-aliased Data objects
class Etype { 
  
    public double value;
    public void setValue(double x)
    {
      value = x;
    }
}

class Add:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Sub:Etype{
  
  public Etype l;
  public Etype r;
  
}
class Mult:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Data{}
class Var:Etype{}
class Const:Etype{}


class Program {
    static object Run() {
        var res = new Data[10];
        
              
        Var []env = new Var[3];
        Var v1;
        Var v2;
        
        env[0] = v1;
        env[0] = v2;
        
        Const c1 = new Const();
        Const c2 = new Const();
       
        

        Sub sb  = new Sub();
        sb.r = env[0];
        sb.l = env[1];
        
        Add ad2 = new Add();
        ad2.l = env[1];
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
        var exp = ad1;        
        
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
        return new { root = exp , variable = env };
        
        
    }
}

HeapDbg/l

using System;

class ListNode { public ListNode next; }
cladd Data {public int val;}
public class Program
{
    public static object Run()
    {
ListNode res = null;

for(int i = 0; i < 10; ++i)
res = new ListNode {next = res, val = new Data()};

return res;
    }
}

HeapDbg/k6

using System;
using System.Collections.Generic;

public class Program
	{
		public static object Run()
		{
			Dictionary<Point, Sphere[]> nestedDict = new Dictionary<int, Sphere[]>();

			for(int i = 0; i < 10; ++i)
			{
				Sphere[] spheres = new Sphere[10];
				Color rgb = new Color { red = 0, blue = 255, green = 0 };

				for(int j = 0; j < 10; ++j)
				{
					Point ctr = new Point { xpos = i, ypos = i + j, zpos = i - j };
					spheres[i] = new Sphere { center = ctr, color = rgb, radius = 3.0F };
				}

				nestedDict.Add(spheres[0].xpos, spheres);
			}

			return nestedDict;
		}
	}

	public class Sphere { public Point center; public Color color; public float radius; }
	public class Color { public int red; public int blue; public int green; }
	public class Point { public float xpos; public float ypos; public float zpos; }

HeapDbg/4P

using System;
public class TreeNode 
	{
		public TreeNode left; public TreeNode right; public Data data;

		public static TreeNode MakeTree(int k)
		{
			if(k == 0)
				return null;
			else
				return new TreeNode { left = MakeTree(k - 1), right = MakeTree(k - 1), data = new Data() };
		}
	}
	
	public class Data { public int val;}

	public class Program
	{
		public static object Run()
		{
			TreeNode res = TreeNode.MakeTree(3);
			return res;
		}
	}

HeapDbg/Fj

// Creates an array of un-aliased Data objects
class Data { }
class }

HeapDbg/mJz

class Eobjects{}
class Etype:Eobjects {public Etype pointsto;} 

class Add:Etype{ public Eobjects l; public Eobjects r; }
class Sub:Etype{ public Eobjects l; public Eobjects r; }
class Mult:Etype{ public Eobjects l; public Eobjects r; }

class Var:Eobjects{}  
class Const:Eobjects{}


class Program {
  
    static Var []env = new Var[3];
    
    static object test(Etype exp)
    {
      
        Var v1= new Var();
        Var v2= new Var();
        Var v3= new Var();
        
        env[0] = v1;
        env[1] = v2;
        Const c1 = new Const();
        Const c2 = new Const();
       
     

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
        exp.pointsto = ad1;
        return new { exp , env };
    }
    static object Run() {
      
        Etype exp = new Etype();
        object ob = test();
        return ob;
    }
}

HeapDbg/Mj

// Creates an array of un-aliased Data objects

class Program {
    static object Run() {
        int i = 1;
    }
}

HeapDbg/up

// Create a scene structure for a simple raytracer
class Program {
    static object Run() {
        ISceneObject[] things = {
            new Sphere { 
                Center = new Vector { X = -0.5F, Y = 1F, Z = 1.5F }, 
                RGB = new Color { Red = 0, Blue = 255, Green = 0 }, 
                Radius = 0.5F },
            new Sphere { 
                Center = new Vector { X = 0F, Y = 1F, Z = -0.25F }, 
                RGB = new Color { Red = 0, Blue = 0, Green = 255 }, 
                Radius = 1F },
            new Plane { 
                Norm = new Vector { X = 0F, Y = 1F, Z = 0F }, 
                RGB = new Color { Red = 192, Blue = 192, Green = 192 }, 
                Offset = 1F }
        };

        Light[] lights = {
            new Light { 
                Pos = new Vector { X = -2F, Y = 2.5F, Z = 0F }, 
                RGB = new Color { Red = 173, Blue = 216, Green = 230 } },
            new Light { 
                Pos = new Vector { X = 2F, Y = 4.5F, Z = 2F }, 
                RGB = new Color { Red = 255, Blue = 127, Green = 0 } }
        };

        var camera = new Camera { 
            Pos = new Vector { X = 2.75F, Y = 2F, Z = 3.75F }, 
            Forward = new Vector { X = -0.6F, Y = 0.5F, Z = 0F } 
        };

        return new { 
            root = new Scene { Things = things, Lights = lights, Camera = camera } 
        };
    }
}

class Scene {
    public ISceneObject[] Things; 
    public Light[] Lights; 
    public Camera Camera; 
}

interface ISceneObject { }
class Sphere : ISceneObject { public Vector Center; public Color RGB; public float Radius; }
class Plane : ISceneObject { public Vector Norm; public Color RGB; public float Offset; }

class Light { public Vector Pos; public Color RGB; }
class Camera { public Vector Pos; public Vector Forward; }

class Vector { public float X; public float Y; public float Z; }
class Color { public int Red; public int Blue; public int Green; }

HeapDbg/Mh

// Creates an array of un-aliased Data objects
class Data { int i; }
class Program {
    static object Run() {
        object res = new { a = new Data[10] };
        for (int i = 0; i < res.Length; ++i)
            res.a[i] = new Data();
        return new { root = res };
    }
}

HeapDbg/mgp

// Create an array of un-aliased Shperes.
// Each a composite object of an unaliased Point object and Color object
class Color { public int red; public int blue; public int green; }
class Point { public float xpos; public float ypos; public float zpos; }
class Sphere { 
    public Point center; 
    public Color color; 
    public float radius; 
}
class Program {
    static object Run() {
        var spheres = new Sphere[10];
        for (int i = 0; i < spheres.Length; ++i) {
            var ctr = new Point { xpos = i, ypos = i + 1, zpos = i - 1 };
            var rgb = new Color { red = i, blue = i, green = i };
            spheres[i] = new Sphere { center = ctr, color = rgb, radius = 3.0F };
        }
        return new { spheres = "eee" };
    }
}

HeapDbg/W

// Creates an array of un-aliased Data objects, some entries are null.
class Data { }
class Program {
    static object Run() {
        var res = new Data[30];
        for (int i = 0; i < 20; ++i) {
            if (i % 2 != 0 && i % 3 != 0)
                res[i] = new Data();
        }
        return new { root = res };
    }
}

HeapDbg/MfU

// Creates an array of un-aliased Data objects
class Etype { 
  
    public double value;
    public void setValue(double x)
    {
      value = x;
    }
}

class Add:Etype{
  
  public Etype l;
  public Etype r;
  
  
}

class Sub:Etype{
  
  public Etype l;
  public Etype r;
  
}
class Mult:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Data{}
class Var:Etype{
  
  
}
class Const:Etype{}


class Program {
    static object Run() {
              
        Var []env = new Var[3];
        
        Var v1= new Var();
        Var v2= new Var();
        Var v3= new Var();
        
        env[0] = v1;
        env[1] = v2;
        Const c1 = new Const();
        Const c2 = new Const();
       
        

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
                
        Etype exp = new Etype();
        exp.l = ad1;
        
        return new { root = exp , v = env };
        
        
    }
}

HeapDbg/mfm

// Creates an array of un-aliased Data objects
class Etype { 
  
    public double value;
    public void setValue(double x)
    {
      value = x;
    }
}

class Add:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Sub:Etype{
  
  public Etype l;
  public Etype r;
  
}
class Mult:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Data{}
class Var:Etype{}
class Const:Etype{}


class Program {
    static object Run() {
              
        Var []env = new Var[3];
        Var v1 = null;
        Var v2 = null;
        
        v1 = env[0];
        v2 = env[1];
        
        Const c1 = new Const();
        Const c2 = new Const();
       
        

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c1;
        
        var exp = ad1;        
        
        
        return new { root = exp , v = env };
        
        
    }
}

HeapDbg/Mf

// Creates an array of un-aliased Data objects, some entries are null.
public class Program
    {
        Program f;
        public static object Run()
        {
            Program param = new Program();
            Program local1 = bar();
            Program local2 = bar();
            local1.f = param;
            local2.f = new Program();
            local2.f.f = new Program();
            return new {root = local1};
        }

        public static Program bar()
        {
            Program r = new Program();
            return r;
        }
    }

HeapDbg/Wt

// Creates an array of un-aliased Data objects, some entries are null.
class Data { }
class Program {
    static object Run() {
        var res = new Data[10];
        for (int i = 0; i < 10; ++i) {
            if (i % 2 != 0 && i % 3 != 0)
                res[i] = new Data();
        }
        var res2 = new Data[5];
        res2[4] = new Data();
        return new { root = res, rott2 = res2 };
    }
}

HeapDbg/slQ

// Creates an array of un-aliased Data objects
class Data { int i; }
class Program {
    static object Run() {
        var res = new Data[10];
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
        return new { root = res };
    }
}

HeapDbg/hk

// Creates an array of un-aliased Data objects
class Data { int x = 42; }
class Program {
    static object Run() {
        var res = new Data[10];
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
        return new { root = res };
    }
}

HeapDbg/1Y

// Create a LinkedList of Data objects
// Self edge on, Next, and label, List
class Data { }
class X extends Data { }
class ListNode { public ListNode Next; public Data Data; }
class Program {
    static object Run() {
        ListNode res = null;
        for (int i = 0; i < 10; ++i)
            res = new ListNode { Next = res, Data = new Data() };
        return new { root = res };
    }
}

HeapDbg/Hg

// Creates an array of un-aliased Data objects
class Data { int a,b,c; }
class Program {
    static object Run() {
        var res = new Data[10];
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
        return new { root = res };
    }
}

HeapDbg/HD

// Creates an array of un-aliased Data objects
class Data { }
class Program {
    static object Run() {
        var res = new Data[11];
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
        return new { root = res };
    }
}

HeapDbg/hC

// Create an array of un-aliased Data objects and one special object
class Data { public int val;}
class Program {
    static object Main() {
        var resa = new Data[10];
        var dspecial = new Data();
        for (int i = 0; i < resa.Length; ++i) {
            if (i == 5)
                resa[i] = dspecial;
            else
                resa[i] = new Data();
        }
        return new { array = resa, special = dspecial };
    }
}

HeapDbg/hB

I went to tons of links bferoe this, what was I thinking?

HeapDbg/OC

using System;

public class Result { public STreeNode tree; public Color scolor;}

	public class Program
	{
		public static object Run()
		{
			Color special = new Color { red = 0, blue = 255, green = 0 };
			STreeNode rtn = STreeNode.MakeTree(3, special);

			return new Result { tree = rtn, scolor = special };
		}
	}

	public class STreeNode
	{
		public STreeNode left; public STreeNode right; public Sphere[] data;

		public static STreeNode MakeTree(int k, Color c)
		{
			if(k == 0)
				return null;
			else
			{

                          Sphere[] sph = new Sphere[5];
				for(int i = 0; i < 5; ++i)
				{
					Point cp = new Point { xpos = k, ypos = k, zpos = k };
					sph[i] = new Sphere { center = cp, color = c, radius = 1F };
				}
				return new STreeNode { left = MakeTree(k - 1, c), right = MakeTree(k - 1, c), data = sph };
			}
		}
	}

	public class Sphere { public Point center; public Color color; public float radius; }
	public class Color { public int red; public int blue; public int green; }
	public class Point { public float xpos; public float ypos; public float zpos; }

HeapDbg/h7

// Creates an array of un-aliased Data objects
class Data { }
class Program {
    static object Run() {

return new { A = new { B = new { C = 1 } } };
    }
}

HeapDbg/h2

// Creates an array of un-aliased Data objects
class Data { }
class Program {
    static object Run() {
        var res = new Data[10];
var asd = new Data[10];
var ads = new Data[10];
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
        return new { root = res };
    }
}

HeapDbg/H

using System;

public class Result { public STreeNode tree; public Color scolor;}

	public class Program
	{
		public static object Run()
		{
			Color special = new Color { red = 0, blue = 255, green = 0 };
			STreeNode rtn = STreeNode.MakeTree(3, special);

			return new Result { tree = rtn, scolor = special };
		}
	}

	public class STreeNode
	{
		public STreeNode left; public STreeNode right; public Sphere[] data;

		public static STreeNode MakeTree(int k, Color c)
		{
			if(k == 0)
				return null;
			else
			{
				Sphere[] sph = new Sphere[5];
				for(int i = 0; i < 5; ++i)
				{
					Point cp = new Point { xpos = k, ypos = k, zpos = k };
					sph[i] = new Sphere { center = cp, color = c, radius = 1F };
				}
			
				return new STreeNode { left = MakeTree(k - 1, c), right = MakeTree(k - 1, c), data = sph };
			}
		}
	}

	public class Sphere { public Point center; public Color color; public float radius; }
	public class Color { public int red; public int blue; public int green; }
	public class Point { public float xpos; public float ypos; public float zpos; }

HeapDbg/eV

xCCcra  <a href="http://vhibeaukkixq.com/">vhibeaukkixq</a>, [url=http://fqcexxhifogz.com/]fqcexxhifogz[/url], [link=http://kebvzyvhizel.com/]kebvzyvhizel[/link], http://fbmpzucwrans.com/

HeapDbg/jN

// Create a LinkedList of Data objects
// Self edge on, Next, and label, List
class Data { }
class X: Data { }
class Y: Data { }
class ListNode { public ListNode Next, Prev; public Data Data; }
class Program {
    static object Run() {
        ListNode res = null;
        for (int i = 0; i < 10; ++i) {
            res = new ListNode { Next = res, Data = new X() };
            res.Next.Prev = res
        }
        return new { root = res };
    }
}

HeapDbg/fO

// Creates an array of un-aliased Data objects, some entries are null.
class Data { System.Random t=new System.Random(); }
class Program {
    static object Run() {
        var res = new Data[10];
        for (int i = 0; i < 10; ++i) {
            if (i % 2 != 0 && i % 3 != 0)
                res[i] = new Data();
        }
        return new { root = res,lol=res };
    }
}

HeapDbg/1p

using System;

//Create a Deep Copy of a Tree of Data objects
namespace TreeCopyDeep
{
	public class Result { public TreeNode orig; public TreeNode copy;}

	public class Program
	{
		public static object Run() //<------------------------------------- RunShowMultiRoots()
		{
			TreeNode torig = TreeNode.MakeTree(3);
			TreeNode tcopy = TreeNode.CopyTreeDeep(torig);

			return new Result { orig = torig, copy = tcopy };
		}
	}

	public class TreeNode
	{
		public TreeNode left; public TreeNode right; public Data data;

		public static TreeNode MakeTree(int k)
		{
			if(k == 0)
				return null;
			else
				return new TreeNode { left = MakeTree(k - 1), right = MakeTree(k - 1), data = new Data() };
		}

		public static TreeNode CopyTreeDeep(TreeNode t)
		{
			if(t == null)
				return null;
			else
				return new TreeNode { left = CopyTreeDeep(t.left), right = CopyTreeDeep(t.right), data = new Data { val = t.data.val } };
		}
	}

	public class Data { public int val;}
}

HeapDbg/CF

class Etype {} 

class Add:Etype{ public Etype l; public Etype r; }
class Sub:Etype{ public Etype l; public Etype r; }
class Mult:Etype{ public Etype l; public Etype r; }

class Var:Etype{}  
class Const:Etype{}


class Program {
  
    static object Run() {
              
        Var []env = new Var[3];
        
        
        
        Var v1= new Var();
        Var v2= new Var();
        Var v3= new Var();
        
        env[0] = v1;
        env[1] = v2;
        Const c1 = new Const();
        Const c2 = new Const();
       
     

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
                
        exp = ad1;
        return new { exp , env };
        
        
    }
}

HeapDbg/cd

// Creates an array of un-aliased Data objects
class Data { public int Value { get { return 3; } } }
class Program {
    static object Run() {
        var res = new Data[10];
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
        return new { root = res };
    }
}

HeapDbg/Cc

// Creates an array of un-aliased Data objects
class Data {
  
  public  string getDeviceID()
  {
    return "123456";
  }
 }
 
 class Test
 {
   
   void print(string s)
   {
     
     string d = s;
   }
   
 }
 
class Program {
    static object Run() {
        var res = new Data();
        var ob = new Test();
        //for (int i = 0; i < res.Length; ++i)
        string s = res.getDeviceID();
           
        ob.print(s);   
        return new { root = res };
    }
}

HeapDbg/CBv

class Eobjects{}
class Etype:Eobjects {public Etype pointsto;} 

class Add:Etype{ public Eobjects l; public Eobjects r; }
class Sub:Etype{ public Eobjects l; public Eobjects r; }
class Mult:Etype{ public Eobjects l; public Eobjects r; }

class Var:Eobjects{}  
class Const:Eobjects{}


class Program {
  
    static Var []env = new Var[3];
    
    static object test(Etype exp)
    {
      
        Var v1= new Var();
        Var v2= new Var();
        Var v3= new Var();
        
        env[0] = v1;
        env[1] = v2;
        Const c1 = new Const();
        Const c2 = new Const();
       
     

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
        exp.pointsto = ad1;
        return new { exp , env };
    }
    static object Run() {
      
        Etype exp = new Etype();
        object ob = test(exp);
        return ob;
    }
}

HeapDbg/CB

// Creates an array of un-aliased Data objects
class Data {
  
  public  string getDeviceID()
  {
    return "12";
  }
 }
 
 class Test
 {
   
   public void print(string s)
   {
     
     string d = s;
   }
   
 }
 
class Program {
    static object Run() {
        var res = new Data();
        var ob = new Test();
        //for (int i = 0; i < res.Length; ++i)
        string s = res.getDeviceID();
           
        string s2 = s + "desh"   
        ob.print(s2);   
        return new { root = res };
    }
}

HeapDbg/jo4

// Creates an array of un-aliased Data objects, some entries are null.
class Data { 
  public int x;
}
class Program {
    static object Run() {
        var res = new Data[10];
        for (int i = 0; i < 10; ++i) {
            if (i % 2 != 0 && i % 3 != 0) {
                res[i].x = 111;
                res[i] = new Data();
            }
        }
        return new { root = res };
    }
}

HeapDbg/as

Ni0sPf  <a href="http://uaiiwmrcnufn.com/">uaiiwmrcnufn</a>, [url=http://ypmlbydgpagy.com/]ypmlbydgpagy[/url], [link=http://qjkftdambbgn.com/]qjkftdambbgn[/link], http://vbmktdaszkcz.com/

HeapDbg/aqz

// Creates an array of un-aliased Data objects
class Etype { 
  
    public double value;
    public void setValue(double x)
    {
      value = x;
    }
}

class Add:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Sub:Etype{
  
  public Etype l;
  public Etype r;
  
}
class Mult:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Data{}
class Var:Etype{}
class Const:Etype{}


class Program {
    static object Run() {
              
        Var []env = new Var[3];
        Var v1 = null;
        Var v2 = null;
        
        env[0] = v1;
        env[0] = v2;
        
        Const c1 = new Const();
        Const c2 = new Const();
       
        

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        
        
        var exp = ad1;        
        
        
        return new { root = exp , variable = env };
        
        
    }
}

HeapDbg/f8

/**
 * Ejemplo de envio de correo simple con JavaMail
 *
 * @author Chuidiang
 *
  */
class EnviarMail
{
    /**
     * main de prueba
     * @param args Se ignoran.
     */
    @SuppressWarnings("unchecked")
	int main(String[] args)
    {
    	ArrayList elements = new ArrayList();
    	elements.add(new Element("rodrigo","ricardo","ana_julia"));
    	elements.add(new Element("joaquin","ricardo","ana_julia"));
    	elements.add(new Element("cristobal","gabriel","marcela"));
    	elements.add(new Element("agustin","gabriel","marcela"));
    	elements.add(new Element("micaela","gabriel","marcela"));
    	elements.add(new Element("gabriel","antonio","anabela"));
    	elements.add(new Element("ana_julia","antonio","anabela"));
    	elements.add(new Element("ricardo","ireneo","norma"));
    	elements.add(new Element("ireneo","ireneo","norma"));
    	elements.add(new Element("pablo","ireneo","norma"));
//    	elements.add(new Element("acid","fire","sulfur"));
//    	elements.add(new Element("acid_rain","acid","rain"));
//    	elements.add(new Element("ai","computer","life"));
//    	elements.add(new Element("alcohol","water","fire"));
//    	elements.add(new Element("alien","space","life"));
//    	elements.add(new Element("aluminum","metal","electricity"));
//    	elements.add(new Element("ape","human","wool"));
//    	elements.add(new Element("aquaman","fish","human"));
//    	elements.add(new Element("aquarium","glass","fish"));
//    	elements.add(new Element("arable_land","soil","tool"));
//    	elements.add(new Element("ash","fire","dust"));
//    	elements.add(new Element("ashtray","ash","glass"));
//    	elements.add(new Element("baby","human","sex"));
//    	elements.add(new Element("bacterium","swamp","life"));
//    	elements.add(new Element("bank","money","brick_house"));
//    	elements.add(new Element("beach","water","sand"));
//    	elements.add(new Element("beast","soil","lizard"));
//    	elements.add(new Element("beer","alcohol","wheat"));
//    	elements.add(new Element("bird","air","egg"));
//    	elements.add(new Element("blood","hunter","bird"));
//    	elements.add(new Element("boat","water","wood"));
//    	elements.add(new Element("boiler","metal","steam"));
//    	elements.add(new Element("bomb","metal","gunpowder"));
//    	elements.add(new Element("bomber","plane","bomb"));
//    	elements.add(new Element("book","paper","feather"));
//    	elements.add(new Element("bread","fire","dough"));
//    	elements.add(new Element("brick","clay","fire"));
//    	elements.add(new Element("brick_house","concrete","brick"));
//    	elements.add(new Element("bug","soil","worm"));
//    	elements.add(new Element("bulb","electricity","glass"));
//    	elements.add(new Element("bungalow","hut","beach"));
//    	elements.add(new Element("business","money","human"));
//    	elements.add(new Element("butterfly","air","worm"));
//    	elements.add(new Element("cart","wood","wheel"));
//    	elements.add(new Element("caviar","fish","fish"));
//    	elements.add(new Element("cd","laser","book"));
//    	elements.add(new Element("cellphone","computer","radiowave"));
//    	elements.add(new Element("cement","clay","limestone"));
//    	elements.add(new Element("ceramics","clay","human"));
//    	elements.add(new Element("cigarette","paper","tobacco"));
//    	elements.add(new Element("clay","swamp","sand"));
//    	elements.add(new Element("cleaner","clobber","human"));
//    	elements.add(new Element("clobber","fabric","patient"));
//    	elements.add(new Element("clone","scientist","livestock"));
//    	elements.add(new Element("clothing","fabric","human"));
//    	elements.add(new Element("cloud","steam","air"));
//    	elements.add(new Element("coal","tree","fire"));
//    	elements.add(new Element("cockleshell","stone","plankton"));
//    	elements.add(new Element("coffee","seeds","energy"));
//    	elements.add(new Element("columbus","sailing_vessel","hero"));
//    	elements.add(new Element("computer","book","tv"));
//    	elements.add(new Element("concrete","water","cement"));
//    	elements.add(new Element("corpse","poison","human"));
//    	elements.add(new Element("cyborg","human","computer"));
//    	elements.add(new Element("developer","sex","computer"));
//    	elements.add(new Element("dinosaur","soil","egg"));
//    	elements.add(new Element("doctor","human","book"));
//    	elements.add(new Element("dough","water","flour"));
//    	elements.add(new Element("dragon","flying_dinosaur","fire"));
//    	elements.add(new Element("drinker","alcohol","human"));
//    	elements.add(new Element("dust","air","soil"));
//    	elements.add(new Element("egg","stone","life"));
//    	elements.add(new Element("electricity","scientist","energy"));
//    	elements.add(new Element("elixer","stone","philosopher"));
//    	elements.add(new Element("energy","air","fire"));
//    	elements.add(new Element("fabric","wool","tool"));
//    	elements.add(new Element("fart","peas","human"));
//    	elements.add(new Element("feather","bird","hunter"));
//    	elements.add(new Element("fern","swamp","moss"));
//    	elements.add(new Element("fire_golem","fire","life"));
//    	elements.add(new Element("firearms","weapon","gunpowder"));
//    	elements.add(new Element("fish","bacterium","plankton"));
//    	elements.add(new Element("flour","wheat","stone"));
//    	elements.add(new Element("flying_dinosaur","dinosaur","air"));
//    	elements.add(new Element("fried_egg","fire","egg"));
//    	elements.add(new Element("fried_meat","fire","meat"));
//    	elements.add(new Element("frog","fish","swamp"));
//    	elements.add(new Element("ghoul","zombie","corpse"));
//    	elements.add(new Element("glass","sand","fire"));
//    	elements.add(new Element("gold","elixer","any_other_element"));
//    	elements.add(new Element("golem","clay","life"));
//    	elements.add(new Element("grass","moss","soil"));
//    	elements.add(new Element("gunpowder","saltpeter","sulfur"));
//    	elements.add(new Element("hacker","pirate","internet"));
//    	elements.add(new Element("hero","warrior","dragon"));
//    	elements.add(new Element("hospital","brick_house","doctor"));
//    	elements.add(new Element("housemd","doctor","vicodin"));
//    	elements.add(new Element("human","golem","life"));
//    	elements.add(new Element("hunter","weapon","human"));
//    	elements.add(new Element("hut","stone","human"));
//    	elements.add(new Element("internet","computer","computer"));
//    	elements.add(new Element("japanese","human","rice"));
//    	elements.add(new Element("kamasutra","book","sex"));
//    	elements.add(new Element("katana","japanese","metal"));
//    	elements.add(new Element("lake","water","water"));
//    	elements.add(new Element("lamp","glass","fire"));
//    	elements.add(new Element("laser","radiowave","fire"));
//    	elements.add(new Element("lava","soil","fire"));
//    	elements.add(new Element("lava_golem","life","lava"));
//    	elements.add(new Element("life","energy","swamp"));
//    	elements.add(new Element("lighthouse","brick_house","lamp"));
//    	elements.add(new Element("limestone","stone","cockleshell"));
//    	elements.add(new Element("livestock","human","beast"));
//    	elements.add(new Element("lizard","snake","worm"));
//    	elements.add(new Element("manga","book","japanese"));
//    	elements.add(new Element("manure","livestock","grass"));
//    	elements.add(new Element("meat","hunter","bird"));
//    	elements.add(new Element("medicine","shaman","poison"));
//    	elements.add(new Element("mercury","fire","metal"));
//    	elements.add(new Element("metal","stone","fire"));
//    	elements.add(new Element("metal_golem","life","metal"));
//    	elements.add(new Element("meteorite","space","stone"));
//    	elements.add(new Element("milk","livestock","human"));
//    	elements.add(new Element("money","gold","paper"));
//    	elements.add(new Element("moss","swamp","seaweed"));
//    	elements.add(new Element("murderer","poison_weapon","human"));
//    	elements.add(new Element("mushroom","soil","seaweed"));
//    	elements.add(new Element("new_york","usa","skyscraper"));
//    	elements.add(new Element("ninja","samuri","poison_weapon"));
//    	elements.add(new Element("nuclearbomb","scientist","bomb"));
//    	elements.add(new Element("ocean","sea","sea"));
//    	elements.add(new Element("oil","water","coal"));
//    	elements.add(new Element("paper","tool","reed"));
//    	elements.add(new Element("patient","bacterium","human"));
//    	elements.add(new Element("peas","arable_land","seeds"));
//    	elements.add(new Element("petrol","oil","tool"));
//    	elements.add(new Element("phantom","nuclearbomb","anything"));
//    	elements.add(new Element("philosopher","grass","scientist"));
//    	elements.add(new Element("phoenix","fire","bird"));
//    	elements.add(new Element("pig-iron","metal","coal"));
//    	elements.add(new Element("pilot","plane","human"));
//    	elements.add(new Element("pirate","murderer","sailing_vessel"));
//    	elements.add(new Element("plane","bird","aluminum"));
//    	elements.add(new Element("plankton","water","bacterium"));
//    	elements.add(new Element("poison","tool","scorpion"));
//    	elements.add(new Element("poison_weapon","poison","weapon"));
//    	elements.add(new Element("pub","beer","brick_house"));
//    	elements.add(new Element("radiation","nuclearbomb","anything"));
//    	elements.add(new Element("radiowave","metal","energy"));
//    	elements.add(new Element("rain","cloud","water"));
//    	elements.add(new Element("reed","swamp","grass"));
//    	elements.add(new Element("rice","arable_land","reed"));
//    	elements.add(new Element("robot","japanese","tool"));
//    	elements.add(new Element("rocket","plane","gunpowder"));
//    	elements.add(new Element("rust","water","metal"));
//    	elements.add(new Element("sailing_boat","boat","fabric"));
//    	elements.add(new Element("sailing_vessel","wooden_ship","fabric"));
//    	elements.add(new Element("salt","metal","acid"));
//    	elements.add(new Element("saltpeter","manure","limestone"));
//    	elements.add(new Element("samurai","japanese","weapon"));
//    	elements.add(new Element("sand","water","stone"));
//    	elements.add(new Element("scientist","doctor","book"));
//    	elements.add(new Element("scorpion","bug","sand"));
//    	elements.add(new Element("sea","lake","salt"));
//    	elements.add(new Element("seaweed","life","water"));
//    	elements.add(new Element("seeds","life","sand"));
//    	elements.add(new Element("sex","human","human"));
//    	elements.add(new Element("shaman","mushroom","human"));
//    	elements.add(new Element("shop","clothing","brickhouse"));
//    	elements.add(new Element("skydiver","clobber","pilot"));
//    	elements.add(new Element("skyscraper","brickhouse","glass"));
//    	elements.add(new Element("snake","sand","worm"));
//    	elements.add(new Element("sniper","firearms","murderer"));
//    	elements.add(new Element("space","ocean","air"));
//    	elements.add(new Element("speedboat","boat","rocket"));
//    	elements.add(new Element("starwars","laser","weapon"));
//    	elements.add(new Element("steam","water","air"));
//    	elements.add(new Element("steam_engine","boiler","coal"));
//    	elements.add(new Element("steam_locomotive","steam_engine","cart"));
//    	elements.add(new Element("steamship","wooden_ship","steam_engine"));
//    	elements.add(new Element("stone","water","lava"));
//    	elements.add(new Element("storm","energy","air"));
//    	elements.add(new Element("submarine","whale","metal"));
//    	elements.add(new Element("submariner","submarine","human"));
//    	elements.add(new Element("sulfur","swamp","bacterium"));
//    	elements.add(new Element("sun","lava","space"));
//    	elements.add(new Element("swamp","water","soil"));
//    	elements.add(new Element("team","cart","beast"));
//    	elements.add(new Element("terrorist","bomb","murderer"));
//    	elements.add(new Element("thunderbird","storm","bird"));
//    	elements.add(new Element("tobacco","fire","grass"));
//    	elements.add(new Element("tool","human","metal"));
//    	elements.add(new Element("torpedo","rocket","water"));
//    	elements.add(new Element("toy","baby","anything"));
//    	elements.add(new Element("tree","soil","seeds"));
//    	elements.add(new Element("turtle","egg","sand"));
//    	elements.add(new Element("tv","radiowave","bulb"));
//    	elements.add(new Element("ufo","alien","rocket"));
//    	elements.add(new Element("usa","columbus","ocean"));
//    	elements.add(new Element("vampire","human","blood"));
//    	elements.add(new Element("vicodin","medicine","medicine"));
//    	elements.add(new Element("vodka","water","alcohol"));
//    	elements.add(new Element("walking_tree","life","tree"));
//    	elements.add(new Element("war","warrior","warrior"));
//    	elements.add(new Element("werewolf","vampire","beast"));
//    	elements.add(new Element("warrior","weapon","hunter"));
//    	elements.add(new Element("warship","wooden_ship","weapon"));
//    	elements.add(new Element("weapon","tool","metal"));
//    	elements.add(new Element("whale","fish","plankton"));
//    	elements.add(new Element("wheat","arable_land","grass"));
//    	elements.add(new Element("wheel","wood","tool"));
//    	elements.add(new Element("wood","tree","tool"));
//    	elements.add(new Element("wooden_ship","wood","boat"));
//    	elements.add(new Element("wool","beast","hunter"));
//    	elements.add(new Element("worm","bacterium","swamp"));
//    	elements.add(new Element("yogurt","milk","bacterium"));
//    	elements.add(new Element("zombie","life","corpse"));

//    	elements.add(new Element("soil","basic element"));
//    	elements.add(new Element("air","basic element"));
//    	elements.add(new Element("fire","basic element"));
//    	elements.add(new Element("water","basic element"));

    	HashMap parents = new HashMap();
    	for (int i = 0 ; i < elements.size(); i++){
    		Element element = (Element) elements.get(i);
    		if ( parents.containsKey(element.getFather()) ) {
    			Parent parent = (Parent) parents.get(element.getFather());
    			parent.addChild(element.getName());
    		} else {
    			parents.put(element.getFather(), new Parent( element.getFather(), element.getName()));
    		};
    		if ( parents.containsKey(element.getMother()) ) {
    			Parent parent = (Parent) parents.get(element.getMother());
    			parent.addChild(element.getName());
    		} else {
    			parents.put(element.getMother(), new Parent( element.getMother(), element.getName()));
    		};
    	}
    	
    	Collection parentsSimple = parents.values();
    	Iterator iterParent = parentsSimple.iterator();
//    	for (int i = 0 ; i < elements.size(); i++){
////    		if (((Element) elements.get(i)).getName().equals("housemd")){
//    		if (!( parents.containsKey(((Element) elements.get(i)).getName()))){
//        		System.out.println("digraph " + i + " {");
//        		drawAscendenceForElements((Element) elements.get(i), (ArrayList) elements.clone());
//        		System.out.println("}\n");
//    		}
//    	}
    	// drawing complete
    	System.out.println("digraph g {");
    	while (iterParent.hasNext()){
    		Parent parent = (Parent) (iterParent.next());
    		Object[] childs = parent.getChilds();
			for (int j = 0; j < childs.length; j++) {
				System.out.println(parent.getName() + " -> " + (String) childs[j]);
			}
    	}
    	System.out.println("}\n");
    	
    	/**
        try
        {
            // Propiedades de la conexión
            Properties props = new Properties();
            props.setProperty("mail.smtp.host", "smtp.gmail.com");
            props.setProperty("mail.smtp.starttls.enable", "true");
            props.setProperty("mail.smtp.port", "587");
            props.setProperty("mail.smtp.user", "rodrigo.peti@gmail.com");
            props.setProperty("mail.smtp.auth", "true");
            // Preparamos la sesion
            Session session = Session.getDefaultInstance(props);

            // Construimos el mensaje
            MimeMessage message = new MimeMessage(session);
            message.setFrom(new InternetAddress("rodrigo.peti@gmail.com"));
            message.addRecipient(
                    Message.RecipientType.TO,
                    new InternetAddress("rmolina@intelap.com"));
            message.setText(
                "Mensajito con Java Mail" + " de los buenos." + "poque si" + " funciona papa! ");

            // Lo enviamos.
            Transport t = session.getTransport("smtp");
            t.connect("smtp.gmail.com", "rodrigo.peti@gmail.com", "rodrorodro");
//            t.connect("rodrigo.peti@gmail.com", "rodrorodro");
            t.sendMessage(message, message.getAllRecipients());

            // Cierre.
            t.close();
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        */
    }

	private static void drawAscendenceForElements(Element element,
			ArrayList anotherElements) {
		if (element!=null){
			Element father = getElement( element.getFather(), anotherElements); 
			anotherElements.remove(father);
			Element mother = getElement( element.getMother(), anotherElements);
			anotherElements.remove(mother);
			drawAscendenceForElements(father, anotherElements);
			drawAscendenceForElements(mother, anotherElements);
			System.out.println( element.getFather() + " -> " + element.getName());
			System.out.println( element.getMother() + " -> " + element.getName());
		}
		
	}

	private static Element getElement(String parent, ArrayList anotherElements) {
		for (int i = 0; i < anotherElements.size(); i++){
			Element element = (Element) anotherElements.get(i);
			if (element.getName().equals(parent)){
				return element;
			}
		}
		return null;
	}
}

HeapDbg/Keo

Grade A stuff. I'm uqnuestinoably in your debt.

HeapDbg/ug

Shoot, so that's that one suppsoes.

HeapDbg/Aw

// Creates an array of un-aliased Data objects
class Data { }
class Program {
    static object Run() {
        var res = new Data[100];
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
        return new { root = res };
    }
}

HeapDbg/G67

// Creates an array of un-aliased Data objects, some entries are null.
class Data { }
class Program {
    static object Run() {
        var res = new Data[10];
        for (int i = 0; i < 10; ++i) {
            //if (i % 2 != 0 && i % 3 != 0)
                res[i] = new Data();
        }
        return new { root = res };
    }
}

HeapDbg/si

// Create a scene structure for a simple raytracer
class Program {
    static object Run() {
        SceneObject[] things = n{
            new Sphere { Center = new Vector { X = -0.5F, Y = 1F, Z = 1.5F }, RGB = new Color { Red = 0, Blue = 255, Green = 0 }, Radius = 0.5F },
            new Sphere { Center = new Vector { X = 0F, Y = 1F, Z = -0.25F }, RGB = new Color { Red = 0, Blue = 0, Green = 255 }, Radius = 1F },
            new Plane { Norm = new Vector { X = 0F, Y = 1F, Z = 0F }, RGB = new Color { Red = 192, Blue = 192, Green = 192 }, Offset = 1F }
        };

        Light[] lights = {
            new Light { Pos = new Vector { X = -2F, Y = 2.5F, Z = 0F }, RGB = new Color { Red = 173, Blue = 216, Green = 230 } },
            new Light { Pos = new Vector { X = 2F, Y = 4.5F, Z = 2F }, RGB = new Color { Red = 255, Blue = 127, Green = 0 } }
        };

        var camera = new Camera { 
            Pos = new Vector { X = 2.75F, Y = 2F, Z = 3.75F }, 
            Forward = new Vector { X = -0.6F, Y = 0.5F, Z = 0F } 
        };

        return new { root = new Scene { Things = things, Lights = lights, Camera = camera } };
    }
}

class Scene { 
    public SceneObject[] Things; 
    public Light[] Lights; 
    public Camera Camera; 
}

interface ISceneObject { }
class Sphere : ISceneObject { public Vector Center; public Color RGB; public float Radius; }
class Plane : ISceneObject { public Vector Norm; public Color RGB; public float Offset; }

class Light { public Vector Pos; public Color RGB; }
class Camera { public Vector Pos; public Vector Forward; }

class Vector { public float X; public float Y; public float Z; }
class Color { public int Red; public int Blue; public int Green; }

HeapDbg/6

// Creates an array of un-aliased Data objects, some entries are null.
class Data { public int Test; }
class Program {
    static object Run() {
        var res = new Data[10];
        for (int i = 0; i < 10; ++i) {
            if (i % 2 != 0 && i % 3 != 0)
                res[i] = new Data() { Test = i};
        }
        return new { root = res };
    }
}

HeapDbg/Jsl

// Creates an array of un-aliased Data objects, some entries are null.
public class Program
    {
        Program f;
        public static object Run()
        {
            Program param = new Program();
            Program local1 = bar();
            Program local2 = bar();
            local1.f = param;
            local2.f = new Program();
            local2.f.f = new Program();
            return new {root = local2};
        }

        public static Program bar()
        {
            Program r = new Program();
            return r;
        }
    }

HeapDbg/3t

// Creates an array of un-aliased Data objects, some entries are null.
public class Program
    {
        Program f;
        public static object run(Program param)
        {
            Program local1 = bar();
            Program local2 = bar();
            local1.f = param;
            local2.f = new Program();
            local2.f.f = new Program();
            return  local1;
        }

        public Program bar()
        {
            Program r = new Program();
            return r;
        }
    }

HeapDbg/L6

I told my garndothmer how you helped. She said, "bake them a cake!"

HeapDbg/12Q

Could not find sample or program hello

HeapDbg/9

// Creates an array of un-aliased Data objects
class Data { }
class Program {
    static object Run() {
        var res = new Data[10];
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
        return new { root = res, o = new object() };
    }
}

HeapDbg/Yy

// Creates an array of un-aliased Data objects
class Data {
  
  public static string getDeviceID()
  {
    return "123456";
  }
 }
class Program {
    static object Run() {
        var res = new Data[10];
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
        return new { root = res };
    }
}

HeapDbg/YW

// Creates an array of un-aliased Data objects

class Eobjects{
  
 public Etype pointer;
  
}

class Etype:Eobjects { 
  
    public double value;
    
    public void setValue(double x)
    {
      value = x;
    }
}

class Add:Etype{
  
  public Etype l;
  public Etype r;
  
  
}

class Sub:Etype{
  
  public Etype l;
  public Etype r;
  
}
class Mult:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Data{}
class Var:Etype{
  
  
}
class Const:Etype{}


class Program {
    static object Run() {
              
        Var []env = new Var[3];
        
        Var v1= new Var();
        Var v2= new Var();
        Var v3= new Var();
        
        env[0] = v1;
        env[1] = v2;
        Const c1 = new Const();
        Const c2 = new Const();
       
        

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
                
        Eobjects  exp = new Eobjects();
        exp.pointer  = ad1; 
        
        return new { root = ad1 , v = env };
        
        
    }
}

HeapDbg/yV

// Creates a Deep Copy of a Tree of Data objects
class Data { public int Value;}
class TreeNode {
    public TreeNode Left; public TreeNode Right; 
    public Data Data;
    public static TreeNode MakeTree(int k) {
        if (k == 0)
            return null;
        else
            return new TreeNode { 
                Left = MakeTree(k - 1), Right = MakeTree(k - 1), 
                Data = new Data() 
            };
    }
    public static TreeNode CopyTreeDeep(TreeNode t) {
        if (t == null)
            return null;
        else
            return new TreeNode { 
                Left = CopyTreeDeep(t.Left), Right = CopyTreeDeep(t.Right), 
                Data = new Data { Value = t.Data.Value } 
            };
    }
}
class Program {
    static object Run() {
        var original = TreeNode.MakeTree(3);
        var copy = TreeNode.CopyTreeDeep(original);

        return new { original = original, copy = copy };
    }
}

HeapDbg/yTE

// Creates an array of un-aliased Data objects

class Eobjects{
  
 Etype pointer;
  
}

class Etype:Eobjects { 
  
    public double value;
    
    public void setValue(double x)
    {
      value = x;
    }
}

class Add:Etype{
  
  public Etype l;
  public Etype r;
  
  
}

class Sub:Etype{
  
  public Etype l;
  public Etype r;
  
}
class Mult:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Data{}
class Var:Eobjects{
  
  
}
class Const:Eobjects{}


class Program {
    static object Run() {
              
        Var []env = new Var[3];
        
        Var v1= new Var();
        Var v2= new Var();
        Var v3= new Var();
        
        env[0] = v1;
        env[1] = v2;
        Const c1 = new Const();
        Const c2 = new Const();
       
        

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
                
        Eobjects  exp = new Eobjects();
        exp.pointer  = ad1; 
        
        return new { root = exp , v = env };
        
        
    }
}

HeapDbg/ysl

// Creates an array of un-aliased Data objects
class Data { }
class Program {
    static object Run() {
        var res = Data[10];
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
        return new { root = res };
    }
}

HeapDbg/yS

//Create an array of un-aliased and aliased Shperes.
// Each a composite object of an unaliased Point object but a shared Color object.
class Program {
    static object Run() {
        var spheres = new Sphere[10];
        var rgb = new Color { red = 0, blue = 255, green = 0 };
        for (int i = 0; i < 10; ++i) {
            var ctr = new Point { xpos = i, ypos = i + 1, zpos = i - 1 };
            spheres[i] = new Sphere { center = ctr, color = rgb, radius = 3.0F };
        }
        return new { root = spheres };
    }
}
class Sphere { public Point center; public Color color; public float radius; }
class Color { public int red; public int blue; public int green; }
class Point { public float xpos; public float ypos; public float zpos; }

HeapDbg/Yr

// Creates an array of un-aliased Data objects
using System;
namespace HelloWorld
{
    class Hello 
    {
        static void Main() 
        {
            Console.WriteLine("Hello World!");

            // Keep the console window open in debug mode.
            Console.WriteLine("Press any key to exit.");
            Console.ReadKey();
        }
    }
}

HeapDbg/yM

// Creates an array of un-aliased Data objects
class Etype { 
  
    public double value;
    public void setValue(double x)
    {
      value = x;
    }
}

class Add:Etype{
  
  public Etype l;
  public Etype r;
  
  
}

class Sub:Etype{
  
  public Etype l;
  public Etype r;
  
}
class Mult:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Data{}
class Var:Etype{
  
  
}
class Const:Etype{}


class Program {
    static object Run() {
              
        Var []env = new Var[3];
        
        Var v1= new Var();
        Var v2= new Var();
        Var v3= new Var();
        
        env[0] = v1;
        env[1] = v2;
        Const c1 = new Const();
        Const c2 = new Const();
       
        

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
                
        Etype exp = new Etype;
        exp.l = ad1;
        
        return new { root = exp , v = env };
        
        
    }
}

HeapDbg/Yj

// Creates a Tree of Data objects
class Data { }
class TreeNode {
    public TreeNode Left;  public TreeNode Right; 
    public Data Data;
    public static TreeNode MakeTree(int k) {
        if (k <= 0)
            return null;
        else
            return new TreeNode { 
                Left = MakeTree(k - 1), 
                Right = MakeTree(k - 1), 
                Data = new Data() 
            };
    }
}
class Program {
    static object Run() {
        return new { root = TreeNode.MakeTree(2) };
    }
}

HeapDbg/p

using System;

public class Program
	{
		public static object Run()
		{
			SceneObject[] things = new SceneObject[3];
			things[0] = new Sphere { Center = new Vector { X = -0.5F, Y = 1F, Z = 1.5F }, RGB = new Color { Red = 0, Blue = 255, Green = 0 }, Radius = 0.5F };
			things[1] = new Sphere { Center = new Vector { X = 0F, Y = 1F, Z = -0.25F }, RGB = new Color { Red = 0, Blue = 0, Green = 255 }, Radius = 1F };
			things[2] = new Plane { Norm = new Vector { X = 0F, Y = 1F, Z = 0F }, RGB = new Color { Red = 192, Blue = 192, Green = 192 }, Offset = 1F };

			Light[] lights = new Light[2];
			lights[0] = new Light { Pos = new Vector { X = -2F, Y = 2.5F, Z = 0F }, new Color { Red = 173, Blue = 216, Green = 230 } };
			lights[1] = new Light { Pos = new Vector { X = 2F, Y = 4.5F, Z = 2F }, new Color { Red = 255, Blue = 127, Green = 0 } };

			Camera camera = new Camera { Pos = new Vector { X = 2.75F, Y = 2F, Z = 3.75F }, Forward = new Vector { X = -0.6F, Y = 0.5F, Z = 0F } };

			return new Scene { Things = things, Lights = lights, Camera = camera };
		}
	}

	public class Scene { public SceneObject[] Things; public Light[] Lights; public Camera Camera; }
	
	public interface SceneObject { }
	public class Sphere : SceneObject { public Vector Center; public Color RGB; public float Radius; }
	public class Plane : SceneObject { public Vector Norm; public Color RGB; public float Offset; }

	public class Light { public Vector Pos; public Color RGB; }
	public class Camera { public Vector Pos; public Vector Forward; }

	public class Vector { public float X; public float Y; public float Z; }
	public class Color { public int Red; public int Blue; public int Green; }

HeapDbg/u5

// Creates an array of un-aliased Data objects
class Data { 
int i = 0;
}
class Program {
    static object Run() {
        var res = new Data[10];
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
        return new { root = res };
    }
}

HeapDbg/yF

class Eobjects{}
class Etype:Eobjects {public Etype pointsto;} 

class Add:Etype{ public Eobjects l; public Eobjects r; }
class Sub:Etype{ public Eobjects l; public Eobjects r; }
class Mult:Etype{ public Eobjects l; public Eobjects r; }

class Var:Eobjects{}  
class Const:Eobjects{}


class Program {
    
    static object test(Etype exp, Var[3])
    {
      
      return new { exp , env };
    }
    static void Run() {
              
        Var []env = new Var[3];
        
        
        
        Var v1= new Var();
        Var v2= new Var();
        Var v3= new Var();
        
        env[0] = v1;
        env[1] = v2;
        Const c1 = new Const();
        Const c2 = new Const();
       
     

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
        Etype exp = new Etype();
        exp = ad1;
        //return new { exp , env };
        
        object ob = test(exp,env);
        return ob;
    }
}

HeapDbg/yD

// Creates an array of un-aliased Data objects
class Data { }
class Program {
    static object Run() {
        var res = new Data[10];
        for (int i = 0; i < res.Length; ++i)
       
        return new { root = res };
    }
}

HeapDbg/w6

// Creates an array of un-aliased Data objects
class Data { }
class Program {
    static object Run() {
      return Run1();
    }

    static object Run1() {
        var res = new Data[10];
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
        return new { root = res };
   }
}

HeapDbg/yc9

// Creates an array of un-aliased Data objects
class Etype { 
  
    public double value;
    public void setValue(double x)
    {
      value = x;
    }
}

class Add:Etype{
  
  public Etype l;
  public Etype r;
  public Etypr arrayIndex;
  
}

class Sub:Etype{
  
  public Etype l;
  public Etype r;
  
}
class Mult:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Data{}
class Var:Etype{}
class Const:Etype{}


class Program {
    static object Run() {
              
        Var []env = new Var[3];
        Var v1 = null;
        Var v2 = null;
        
        env[0].arrayIndex = v1;
        env[0].arrayIndex = v2;
        
        Const c1 = new Const();
        Const c2 = new Const();
       
        

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
        var exp = ad1;        
        
        
        return new { root = exp , v = env };
        
        
    }
}

HeapDbg/YC5

gfaCLP  <a href="http://tqafnqnweyhv.com/">tqafnqnweyhv</a>, [url=http://amtnnxmpigbs.com/]amtnnxmpigbs[/url], [link=http://knfuogibwude.com/]knfuogibwude[/link], http://zawxwjhibmau.com/

HeapDbg/pll

private void newFilter(){
		RowFilter<ResponseTableModel, Object> rf = null;
		 try
		 {
			// rf = RowFilter.regexFilter(filterText.getText(), 0);
	     }catch(java.util.regex.PatternSyntaxException e) {
	    	 return;
	     }
	}

HeapDbg/Y2u

// Creates an array of un-aliased Data objects
class Data { }
class Program {
    TestHeapCloning f;
        int h;
        public void foo(TestHeapCloning param)
        {
            TestHeapCloning local1 = bar();
            TestHeapCloning local2 = bar();
            local1.f = param;
            local2.f = new TestHeapCloning();
            local2.f.h = 1;
        }

        public TestHeapCloning bar()
        {
            TestHeapCloning r = new TestHeapCloning();
            return r;
        }    
}

HeapDbg/y2

This aritlce went ahead and made my day.

HeapDbg/Y

using System;

class Hello { public World World; }
class World { }
public class Program
{
    public static object Run()
    {
        return new Hello { World = new World() };
    }
}

HeapDbg/u

using System;

public class Result { public STreeNode tree; public Color scolor;}

	public class Program
	{
		public static object Run()
		{
			Color special = new Color { red = 0, blue = 255, rreen = 0 };
			STreeNode rtn = STreeNode.MakeTree(3, special);

			return new Result { tree = rtn, scolor = special };
		}
	}

	public class STreeNode
	{
		public STreeNode left; public STreeNode right; public Sphere[] data;

		public static STreeNode MakeTree(int k, Color c)
		{
			if(k == 0)
				return null;
			else
			{
				Sphere[] sph = new Sphere[5];
				for(int i = 0; i < 5; ++i)
				{
					Point cp = new Point { xpos = k, ypos = k, zpos = k };
					sph[i] = new Sphere { center = cp, color = c, radius = 1F };
				}
			
				return new STreeNode { left = MakeTree(k - 1, c), right = MakeTree(k - 1, c), data = sph };
			}
		}
	}

	public class Sphere { public Point center; public Color color; public float radius; }
	public class Color { public int red; public int blue; public int green; }
	public class Point { public float xpos; public float ypos; public float zpos; }

HeapDbg/2D

// Creates a Tree of Data objects
class Data { }
class TreeNode {
    public TreeNode Left;  public TreeNode Right; 
    public Data Data;
    public static TreeNode MakeTree(int k) {
        if (k <= 0)
            return null;
        else
            return new TreeNode { 
                Left = MakeTree(k - 1), 
                Right = MakeTree(k - 1), 
                Data = new Data() 
            };
    }
}
class Program {
    static object Run() {
        return new { root = TreeNode.MakeTree(1) };
    }
}

HeapDbg/t4

// Creates an array of un-aliased Data objects
class Data { }
class Program {
    static object Run() {
        var res = new Data[10];
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
        return new  root;
    }
}

HeapDbg/F

using System;

public class TreeNode
	{
		public TreeNode left; public TreeNode right; public Data data;

		public static TreeNode MakeTree(int k)
		{
			if(k == 0)
				return null;
			else
				return new TreeNode { left = MakeTree(k - 1), right = MakeTree(k - 1), data = new Data() };
		}

		public static TreeNode CopyTreeShallow(TreeNode t)
		{
			if(t == null)
				return null;
			else
				return new TreeNode { left = CopyTreeShallow(t.left), right = CopyTreeShallow(t.right), data = t.data };
		}
	}

	public class Data { public int val;}
	public class Result { public TreeNode orig; public TreeNode copy;}

	public class Program
	{
		public static object Run()
		{
			TreeNode torig = TreeNode.MakeTree(3);
			TreeNode tcopy = TreeNode.CopyTreeShallow(torig);

			return new Result { orig = torig, copy = tcopy };
		}
	}

HeapDbg/ROP

// Creates an array of un-aliased Data objects
class Etype { 
  
    public double value;
    public void setValue(double x)
    {
      value = x;
    }
}

class Add:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Sub:Etype{
  
  public Etype l;
  public Etype r;
  
}
class Mult:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Data{}
class Var:Etype{}
class Const:Etype{}


class Program {
    static object Run() {
            
        var env = new Var[3];
        
        
                
        Const c1 = new Const();
        Const c2 = new Const();
       
        

        Sub sb  = new Sub();
        sb.r = env[0];
        sb.l = env[1];
        
        Add ad2 = new Add();
        ad2.l = env[1];
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        
        
        var exp = ad1;        
        
        
        return new { root = exp , variable = env };
        
        
    }
}

HeapDbg/os

// Creates an array of un-aliased Data objects, some entries are null.
class Data { }
class Program {
    static object Run() {
        var res = new Data[15];
        for (int i = 0; i < 15; ++i) {
            if (i % 2 != 0 && i % 3 != 0)
                res[i] = new Data();
        }
        return new { root = res };
    }
}

HeapDbg/3Z7

// Create a LinkedList of Data objects
// Self edge on, Next, and label, List
class Data { }
class ListNode { public ListNode Next; public Data Data; }
class Program {
    static object Run() {
        ListNode res = null;
        for (int i = 0; i < 10; ++i) {
            res = new ListNode { Next = res, Data = new Data() };
if (i == 5)
            res = new ListNode { Next = null, Data = null };
        }
        return new { root = res };
    }
}

HeapDbg/RJ

class Eobjects{}
class Etype:Eobjects {public Etype pointsto;} 

class Add:Etype{ public Eobjects l; public Eobjects r; }
class Sub:Etype{ public Eobjects l; public Eobjects r; }
class Mult:Etype{ public Eobjects l; public Eobjects r; }

class Var:Eobjects{}  
class Const:Eobjects{}


class Program {
    
    static object test(Etype exp, Var [] env)
    {
      
      return new { exp , env };
    }
    static object Run() {
              
        Var []env = new Var[3];
        
        
        
        Var v1= new Var();
        Var v2= new Var();
        Var v3= new Var();
        
        env[0] = v1;
        env[1] = v2;
        Const c1 = new Const();
        Const c2 = new Const();
       
     

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
        Etype exp = new Etype();
        exp.pointsto = ad1;
        return new { exp , env };
        
     
       
    }
}

HeapDbg/RiH

// Creates an array of un-aliased Data objects

class Eobjects{
  
 Etype pointer;
  
}

class Etype:Eobjects { 
  
    public double value;
    
    public void setValue(double x)
    {
      value = x;
    }
}

class Add:Etype{
  
  public Etype l;
  public Etype r;
  
  
}

class Sub:Etype{
  
  public Etype l;
  public Etype r;
  
}
class Mult:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Data{}
class Var:Eobjects{
  
  
}
class Const:Eobjects{}


class Program {
    static object Run() {
              
        Var []env = new Var[3];
        
        Var v1= new Var();
        Var v2= new Var();
        Var v3= new Var();
        
        env[0] = v1;
        env[1] = v2;
        Const c1 = new Const();
        Const c2 = new Const();
       
        

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
                
        Eobjects  exp = new Eobject();
        exp.pointer  = ad1; 
        
        return new { root = exp , v = env };
        
        
    }
}

HeapDbg/j0P

// Create a LinkedList of Data objects
// Self edge on, Next, and label, List
class Data { }
class X: Data { }
class Y: Data { }
class ListNode { public ListNode Next, Prev; public Data Data; }
class Program {
    static object Run() {
        ListNode res = null;
        for (int i = 0; i < 10; ++i) {
            res = new ListNode { Next = res, Data = new X() };
        }
        while(res != null) {
            if (res.next != null)
                res.next.prev = res;
                res = res.next;
        }
        return new { root = res };
    }
}

HeapDbg/Mb

// Creates an array of un-aliased Data objects
class Data { }
class Program {
    static object Run() {
        var res = new Data[10];
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
        return new { root = res };
    }
}

HeapDbg/F9

Rcmocg  <a href="http://cyrshdxqyfao.com/">cyrshdxqyfao</a>, [url=http://ekftnpicyqwj.com/]ekftnpicyqwj[/url], [link=http://myrceivpwiwp.com/]myrceivpwiwp[/link], http://ghuyxyueddjp.com/

HeapDbg/M0B

// Create a LinkedList of Data objects
// Self edge on, Next, and label, List
class Data { }
class ListNode { public ListNode Next; public Data Data; }
class Program {
    static object Run() {
        ListNode res = null;
        ListNode res_init = null;
        for (int i = 0; i < 10; ++i)
{            res = new ListNode { Next = res, Data = new Data() };
if (i==0) res_init=res;}
        return new { root = res };
    }
}

HeapDbg/7

using System;
using System.Collections.Generic;
public static object Run()
		{
			Dictionary<Point, Sphere[]> nestedDict = new Dictionary<int, Sphere[]>();

			for(int i = 0; i < 10; ++i)
			{
				Sphere[] spheres = new Sphere[10];
				Color rgb = new Color { red = 0, blue = 255, green = 0 };

				for(int j = 0; j < 10; ++j)
				{
					Point ctr = new Point { xpos = i, ypos = i + j, zpos = i - j };
					spheres[i] = new Sphere { center = ctr, color = rgb, radius = 3.0F };
				}

				nestedDict.Add(spheres[0], spheres);
			}

			return nestedDict;
		}	public class Sphere { public Point center; public Color color; public float radius; }
	public class Color { public int red; public int blue; public int green; }
	public class Point { public float xpos; public float ypos; public float zpos; }

HeapDbg/m

using System;

public class Result { public STreeNode tree; public Color scolor;}

	public class Program
	{
		public static object Run()
		{
			Color special = new Color { Red = 0, Blue = 255, Green = 0 };
			STreeNode rtn = STreeNode.MakeTree(3);

			return new Result { tree = rtn, scolor = special };
		}
	}
	public class STreeNode
	{
		public STreeNode left; public STreeNode right; public Sphere[] data;

		public static STreeNode MakeTree(int k, Color c)
		{
			if(k == 0)
				return null;
			else
			{
				Sphere[] sph = new Sphere[5];
				for(int i = 0; i < 5; ++i)
					sph[i] = new Sphere { Center = new Point { xpos = k, ypos = k, zpos = k }, Color = c, radius = 1F };
			
				return new STreeNode { left = MakeTree(k - 1, c), right = MakeTree(k - 1, c), data = sph };
			}
		}
	}

	public class Sphere { public Point center; public Color color; public float radius; }
	public class Color { public int red; public int blue; public int green; }
	public class Point { public float xpos; public float ypos; public float zpos; }

HeapDbg/lZ

// Creates an array of un-aliased Data objects
class Data { }
class Program {
    static object Run() {
        var res = new Data[20];
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
        return new { root = res };
    }
}

HeapDbg/LW

// Creates an array of un-aliased Data objects
class Data { int a,b,c; }
class Program {
    static object Run() {
        var res = new Data[10,10];
        for (int i = 0; i < 10; ++i)
            res[i,0] = new Data();
        return new { root = res };
    }
}

HeapDbg/gYO

Could not find sample or program http584747research.microsoft.com47

HeapDbg/K1

//Create an array of un-aliased and aliased Shperes.
// Each a composite object of an unaliased Point object but a shared Color object.
class Program {
    static object Run() {
        var spheres = new Sphere[10];
        var rgb = new Color { red = 0, blue = 255, green = 0 };
        for (int i = 0; i < 10; ++i) {
            var ctr = new Point { xpos = i, ypos = i + 1, zpos = i - 1 };
            spheres[i] = new Sphere { center = ctr, color = rgb, radius = 3.0F };
        }
        return new { root = spheres };
    }
}
class Sphere { public Point center; public Color color; public float radius; }
class Color { public int red; public int blue; public int green; }
class Point { public float xpos; public float ypos; public float zpos; }

HeapDbg/j0

// Creates an array of un-aliased Data objects, some entries are null.
class Data { 
  public Dbtb other;
}
class Dbtb {
}
class Program {
    static object Run() {
        var res = new Data[10];
        var r = new Dbtb();
        for (int i = 0; i < 10; ++i) {
            if (i % 2 != 0 && i % 3 != 0) {
                res[i] = new Data();
                res[i].other = r;
            }
        }
        return new { root = res };
    }
}

HeapDbg/GU

Could not find sample or program PureMethod

HeapDbg/x

// Create a LinkedList of Data objects
// Self edge on, Next, and label, List
class Data { }
class ListNode { public ListNode Next; public Data Data; }
class Program {
    static object Run() {
        ListNode res = null;
        for (int i = 0; i < 10; ++i)
            res = new ListNode { Next = res, Data = new Data() };
        return new { root = res };
    }
}

HeapDbg/AJ

// Creates an array of un-aliased Data objects, some entries are null.
class Data { }
class Program {
    static object Run() {
        var res = new Data[10];
        for (int i = 0; i < 10; ++i) {
            if (i % 2 != 0 && i % 3 != 0)
                res[i] = new Data();
        }
        return new { root = res };
    }
}

HeapDbg/Glp

// Creates an array of un-aliased Data objects
class Data { }
class Program {
    static object Run() {
        var res = new Data[10];
        for (int i = 0; i <= res.Length; ++i)
            res[i] = new Data();
        return new { root = res };
    }
}

HeapDbg/k5

// Creates an array of un-aliased Data objects
class Data { int a,b,c; }
class Program {
    static object Run() {
        var res = new Data[10][10];
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data[10];
        return new { root = res };
    }
}

HeapDbg/ESE

// Creates an array of un-aliased Data objects
class Data { }
class Program {
    static object Run() {
        var res = new Data[10];
        for (int i = 1; i < res.Length; ++i)
            res[i] = new Data();
        return new { root = res };
    }
}

HeapDbg/Es

// Creates an array of un-aliased Data objects
class Data { }
class Program {
    static object Run() {
        var res = new Data[10];
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
        return 1;
    }
}

HeapDbg/eRe

// Creates an array of un-aliased Data objects
class Etype { 
  
    public double value;
    public void setValue(double x)
    {
      value = x;
    }
}

class Add:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Sub:Etype{
  
  public Etype l;
  public Etype r;
  
}
class Mult:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Data{}
class Var:Etype{}
class Const:Etype{}


class Program {
    static object Run() {
        var res = new Data[10];
        
              
        Var []env = new Var[3];
        Const c = new Const();
        c.setValue(6);
        

        Sub sb  = new Sub();
        sb.r = env[0];
        sb.l = env[1];
        
        Add ad2 = new Add();
        ad2.l = env[1];
        ad2.r = c;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c;
        
        //Add exp = ad1;        
        
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
        return new { exp = ad1 , variable = env };
        
        
    }
}

HeapDbg/ebXK

class Etype {public Etype pointsto;} 

class Add:Etype{ public Etype l; public Etype r; }
class Sub:Etype{ public Etype l; public Etype r; }
class Mult:Etype{ public Etype l; public Etype r; }

class Var:Etype{}  
class Const:Etype{}


class Program {
    static object Run() {
              
        Var []env = new Var[3];
        
        
        
        Var v1= new Var();
        Var v2= new Var();
        Var v3= new Var();
        
        env[0] = v1;
        env[1] = v2;
        Const c1 = new Const();
        Const c2 = new Const();
       
     

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
        Etype exp = new Etype();        
        exp.pointsto = ad1;
        return new { exp , env };
        
        
    }
}

HeapDbg/NSm

using System;
using System.Collections.Generic;

public class Program
	{
		public static object Run()
		{
			Dictionary<Point, Sphere[]> nestedDict = new Dictionary<Point, Sphere[]>();

			for(int i = 0; i < 10; ++i)
			{
				Sphere[] spheres = new Sphere[10];
				Color rgb = new Color { red = 0, blue = 255, green = 0 };

				for(int j = 0; j < 10; ++j)
				{
					Point ctr = new Point { xpos = i, ypos = i + j, zpos = i - j };
					spheres[i] = new Sphere { center = ctr, color = rgb, radius = 3.0F };
				}

				nestedDict.Add(spheres[0].center, spheres);
			}

			return nestedDict;
		}
	}

	public struct Sphere { public Point center; public Color color; public float radius; }
	public class Color { public int red; public int blue; public int green; }
	public class Point { public float xpos; public float ypos; public float zpos; }

HeapDbg/C0y

// Creates an array of un-aliased Data objects
class Etype { 
  
    public double value;
    public void setValue(double x)
    {
      value = x;
    }
}

class Add:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Sub:Etype{
  
  public Etype l;
  public Etype r;
  
}
class Mult:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Data{}
class Var:Etype{}
class Const:Etype{}


class Program {
    static object Run() {
        var res = new Data[10];
        
              
        Var []env = new Var[3];
        Const c1 = new Const();
        Const c2 = new Const();
       
        

        Sub sb  = new Sub();
        sb.r = env[0];
        sb.l = env[1];
        
        Add ad2 = new Add();
        ad2.l = env[1];
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
        //Add exp = ad1;        
        
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
        return new { exp = ad1 , variable = env };
        
        
    }
}

HeapDbg/C

using System;
	public class Result { public TreeNode orig; public TreeNode copy;}

	public class Program
	{
		public static object Run() //<------------------------------------- RunShowMultiRoots()
		{
			TreeNode torig = TreeNode.MakeTree(3);
			TreeNode tcopy = TreeNode.CopyTreeDeep(torig);

			return new Result { orig = torig, copy = tcopy };
		}
	}

	public class TreeNode
	{
		public TreeNode left; public TreeNode right; public Data data;

		public static TreeNode MakeTree(int k)
		{
			if(k == 0)
				return null;
			else
				return new TreeNode { left = MakeTree(k - 1), right = MakeTree(k - 1), data = new Data() };
		}

		public static TreeNode CopyTreeDeep(TreeNode t)
		{
			if(t == null)
				return null;
			else
				return new TreeNode { left = CopyTreeDeep(t.left), right = CopyTreeDeep(t.right), data = new Data { val = t.data.val } };
		}
	}

	public class Data { public int val;}

HeapDbg/apl

// Creates an array of un-aliased Data objects
class Data {
  
  public  string getDeviceID()
  {
    return "123456";
  }
 }
class Program {
    static object Run() {
        var res = new Data();
        
        //for (int i = 0; i < res.Length; ++i)
            string s = res.getDeviceID();
        return new { root = res };
    }
}

HeapDbg/aoT

// Creates an array of un-aliased Data objects
class Data {
  
  public static string getDeviceID()
  {
    return "123456";
  }
 }
class Program {
    static object Run() {
        var res = new Data();
        
        //for (int i = 0; i < res.Length; ++i)
            string s = res.getDeviceID();
        return new { root = res };
    }
}

HeapDbg/96I

// Creates an array of un-aliased Data objects
class Etype { 
  
    public double value;
    public void setValue(double x)
    {
      value = x;
    }
}

class Add:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Sub:Etype{
  
  public Etype l;
  public Etype r;
  
}
class Mult:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Data{}
class Var:Etype{}
class Const:Etype{}


class Program {
    static object Run() {
        var res = new Data[10];
        
              
        Var []env = new Var[3];
        Var v1 = null;
        Var v2 = null;
        
        env[0] = v1;
        env[0] = v2;
        
        Const c1 = new Const();
        Const c2 = new Const();
       
        

        Sub sb  = new Sub();
        sb.r = env[0];
        sb.l = env[1];
        
        Add ad2 = new Add();
        ad2.l = env[1];
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
        var exp = ad1;        
        
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
        return new { root = exp , variable = env };
        
        
    }
}

HeapDbg/Av

// Creates an array of un-aliased Data objects
class Data { } class Data2 { }
class Program {
    static object Run() {
        var res = new object[10];
        for (int i = 0; i < res.Length; ++i)
            res[i] = i % 2 == 0 ? (object)new Data2(): new StringBuilder();
        return new { root = res };
    }
}

HeapDbg/ed0

// Create a LinkedList of Data objects
// Self edge on, Next, and label, List
class Data { }
class ListNode { public ListNode Next,Prev; public Data Data; }
class Program {
    static object Run() {
        ListNode res = null;
        for (int i = 0; i < 10; ++i) {
            res = new ListNode { Next = res, Data = new Data() };
            if (res.Next != null) {
                res.Next.Prev = res;
            }
        }
        return new { root = res };
    }
}

HeapDbg/EK

// Creates an array of un-aliased Data objects
class Data { private int prop; }
class Program {
    static object Run() {
        var res = new Data[10];
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
        return new Data();//{ root = res };
    }
}

HeapDbg/3G

L98AYt  <a href="http://mbdfjmnneelp.com/">mbdfjmnneelp</a>, [url=http://zibdauqndknx.com/]zibdauqndknx[/url], [link=http://jooaycyjubhp.com/]jooaycyjubhp[/link], http://dhpsnvdytepo.com/

HeapDbg/KC

using System;
using System.Collections.Generic;

public class Program
	{
		public static object Run()
		{
			Dictionary<int, Sphere[]> nestedDict = new Dictionary<int, Sphere[]>();

			for(int i = 0; i < 10; ++i)
			{
				Sphere[] spheres = new Sphere[10];
				Color rgb = new Color { red = 0, blue = 255, green = 0 };

				for(int j = 0; j < 10; ++j)
				{
					Point ctr = new Point { xpos = i, ypos = i + j, zpos = i - j };
					spheres[i] = new Sphere { center = ctr, color = rgb, radius = 3.0F };
				}

				nestedDict.Add(i, spheres);
			}

			return nestedDict;
		}
	}

	public class Sphere { public Point center; public Color color; public float radius; }
	public class Color { public int red; public int blue; public int green; }
	public class Point { public float xpos; public float ypos; public float zpos; }

HeapDbg/2f

// Creates an array of un-aliased Data objects
class Etype { 
  
    public double value;
    public void setValue(double x)
    {
      value = x;
    }
}

class Add:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Sub:Etype{
  
  public Etype l;
  public Etype r;
  
}
class Mult:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Data{}
class Var:Etype{}
class Const:Etype{}


class Program {
    static object Run() {
        var res = new Data[10];
        
              
        Var []env = new Var[3];
        Const c1 = new Const();
        Const c2 = new Const();
        c1.setValue(5);
        c1.setValue(6);
        

        Sub sb  = new Sub();
        sb.l = env[0];
        sb.l = env[1];
        
        Add ad2 = new Add();
        ad2.l = env[1];
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c1;
        
        var exp = ad1;        
        
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
        return new { root = exp,env };
        
        
    }
}

HeapDbg/1lV

// Creates an array of un-aliased Data objects, some entries are null.
class Data { 
  public int x;
}
class Program {
    static object Run() {
        var res = new Data[10];
        for (int i = 0; i < 10; ++i) {
            if (i % 2 != 0 && i % 3 != 0) {
                res[i] = new Data();
                res[i].x = 111;
            }
        }
        return new { root = res };
    }
}

HeapDbg/2

JyB8sG  <a href="http://okvbxapmwnox.com/">okvbxapmwnox</a>, [url=http://xabbpmhokeig.com/]xabbpmhokeig[/url], [link=http://athdykrszdgv.com/]athdykrszdgv[/link], http://kcbddgboobkd.com/

HeapDbg/T

// Creates a Deep Copy of a Tree of Data objects
class Data { public int Value;}
class TreeNode {
    public TreeNode Left; public TreeNode Right; 
    public Data Data;
    public static TreeNode MakeTree(int k) {
        if (k == 0)
            return null;
        else
            return new TreeNode { 
                Left = MakeTree(k - 1), Right = MakeTree(k - 1), 
                Data = new Data() 
            };
    }
    public static TreeNode CopyTreeDeep(TreeNode t) {
        if (t == null)
            return null;
        else
            return new TreeNode { 
                Left = CopyTreeDeep(t.Left), Right = CopyTreeDeep(t.Right), 
                Data = new Data { Value = t.Data.Value } 
            };
    }
}
class Program {
    static object Run() {
        var original = TreeNode.MakeTree(3);
        var copy = TreeNode.CopyTreeDeep(original);

        return new { original = original, copy = copy };
    }
}

HeapDbg/sz

Could not find sample or program http584747rise4fun.com47images47logo_msr_small.png

HeapDbg/sYv

// Creates an array of un-aliased Data objects
class Etype { 
  
    public double value;
    public void setValue(double x)
    {
      value = x;
    }
}

class Add:Etype{
  
  public Etype l;
  public Etype r;
  
  
}

class Sub:Etype{
  
  public Etype l;
  public Etype r;
  
}
class Mult:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Data{}
class Var:Etype{
  
  
}
class Const:Etype{}


class Program {
    static object Run() {
              
        Var []env = new Var[3];
        
        Var v1= new Var();
        Var v2= new Var();
        Var v3= new Var();
        
        env[0] = v1;
        env[1] = v2;
        Const c1 = new Const();
        Const c2 = new Const();
       
        

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
                
        var exp = new Etype();
        exp = ad1;
        
        return new { root = exp , v = env };
        
        
    }
}

HeapDbg/su

// Creates an array of un-aliased Data objects
class Data { }
class Program {
    static object Run() {
        var res = new Data[10];
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
//        return new { root = res };
    }
}

HeapDbg/spK

class Eobjects{}
class Etype:Eobjects {public Etype pointsto;} 

class Add:Etype{ public Eobjects l; public Eobjects r; }
class Sub:Etype{ public Eobjects l; public Eobjects r; }
class Mult:Etype{ public Eobjects l; public Eobjects r; }

class Var:Eobjects{}  
class Const:Eobjects{}


class Program {
    
    static object test(Etype exp, Var[])
    {
      
      return new { exp , env };
    }
    static void Run() {
              
        Var []env = new Var[3];
        
        
        
        Var v1= new Var();
        Var v2= new Var();
        Var v3= new Var();
        
        env[0] = v1;
        env[1] = v2;
        Const c1 = new Const();
        Const c2 = new Const();
       
     

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
        Etype exp = new Etype();
        exp = ad1;
        //return new { exp , env };
        
        object ob = test(exp,env);
        return ob;
    }
}

HeapDbg/o4

// Creates a Deep Copy of a Tree of Data objects
class Data { public int Value;}
class TreeNode {
    public TreeNode Left; public TreeNode Right; 
    public Data Data;
    public static TreeNode MakeTree(int k) {
        if (k == 0)
            return null;
        else
            return new TreeNode { 
                Left = MakeTree(k - 1), Right = MakeTree(k - 1), 
                Data = new Data() 
            };
    }
    public static TreeNode CopyTreeDeep(TreeNode t) {
        if (t == null)
            return null;
        else
            return new TreeNode { 
                Left = t.Left, Right = CopyTreeDeep(t.Right), 
                Data = new Data { Value = t.Data.Value } 
            };
    }
}
class Program {
    static object Run() {
        var original = TreeNode.MakeTree(3);
        var copy = TreeNode.CopyTreeDeep(original);

        return new { original = original, copy = copy };
    }
}

HeapDbg/O

using System;

public class Program
	{
		public static object Run()
		{
			SceneObject[] things = new SceneObject[3];
			things[0] = new Sphere { Center = new Vector { X = -0.5F, Y = 1F, Z = 1.5F }, RGB = new Color { Red = 0, Blue = 255, Green = 0 }, Radius = 0.5F };
			things[1] = new Sphere { Center = new Vector { X = 0F, Y = 1F, Z = -0.25F }, RGB = new Color { Red = 0, Blue = 0, Green = 255 }, Radius = 1F };
			things[2] = new Plane { Norm = new Vector { X = 0F, Y = 1F, Z = 0F }, RGB = new Color { Red = 192, Blue = 192, Green = 192 }, Offset = 1F };

			Light[] lights = new Light[2];
			lights[0] = new Light { Pos = new Vector { X = -2F, Y = 2.5F, Z = 0F }, new Color { Red = 173, Blue = 216, Green = 230 } };
			lights[1] = new Light { Pos = new Vector { X = 2F, Y = 4.5F, Z = 2F }, new Color { Red = 255, Blue = 127, Green = 0 } };

			Camera camera = new Camera { Pos = new Vector { X = 2.75F, Y = 2F, Z = 3.75F }, Forward = new Vector { X = -0.6F, Y = 0.5F, Z = 0F } };

			return new Scene { Things = things, Lights = lights, Camara = camera };
		}
	}

	public class Scene { SceneObject[] Things; public Light[] Lights; public Camera Camera; }
	
	public interface SceneObject { }
	public class Sphere : SceneObject { public Vector Center; public Color RGB; public float Radius; }
	public class Plane : SceneObject { public Vector Norm; public Color RGB; public float Offset; }

	public class Light { public Vector Pos; public Color RGB; }
	public class Camera { public Vector Pos; public Vector Forward; }

	public class Vector { public float X; public float Y; public float Z; }
	public class Color { public int Red; public int Blue; public int Green; }

HeapDbg/Nw

// Creates an array of un-aliased Data objects
class Data {
  public int variable;
 }
class Program {
    static object Run() {
        var res = new Data[10];
        var res2 = new Data[10];
        for (int i = 0; i < res.Length; ++i)
        {
          
        
            Data data = new Data();
            data.variable = 5;
            res[i] = data;
            }
        return new { root = res };
        
        
    }
}

HeapDbg/nV

class A { 

   public:
      void foo(){
         std::cout << " Things " << std::endl;
      } 


};

int Run(){
     A** a = new A[52];
     return a;
}

HeapDbg/wLV

// Creates an array of un-aliased Data objects, some entries are null.
class Data { 
  int x;
}
class Program {
    static object Run() {
        var res = new Data[10];
        for (int i = 0; i < 10; ++i) {
            if (i % 2 != 0 && i % 3 != 0)
                res[i] = new Data();
        }
        return new { root = res };
    }
}

HeapDbg/a

using System;

public class Program
	{
		public static object Run()
		{
			STreeNode rtn = STreeNode.MakeTree(3);
			return rtn;
		}
	}

	public class STreeNode
	{
		public STreeNode left; public STreeNode right; public Sphere[] data;

		public static STreeNode MakeTree(int k, Color c)
		{
			if(k == 0)
				return null;
			else
			{
				Sphere[] sph = new Sphere[5];
				for(int i = 0; i < 5; ++i)
					sph[i] = new Sphere { Center = new Point { xpos = k, ypos = k, zpos = k }, Color = c, radius = 1F };
			
				return new STreeNode { left = MakeTree(k - 1), right = MakeTree(k - 1), data = sph };
			}
		}
	}

	public class Sphere { public Point center; public Color color; public float radius; }
	public class Color { public int red; public int blue; public int green; }
	public class Point { public float xpos; public float ypos; public float zpos; }

HeapDbg/Nr

// Creates an array of un-aliased Data objects
class Data { }
class Program {
    static object Run() {
        var i = 5;
return i;
    }
}

HeapDbg/Ds

using System;

public class TreeNode
	{
		public TreeNode left; public TreeNode right; public Data data;

		public static TreeNode MakeTree(int k)
		{
			if(k == 0)
				return null;
			else
				return new TreeNode { left = MakeTree(k - 1), right = MakeTree(k - 1), data = new Data() };
		}

		public static TreeNode CopyTreeShallow(TreeNode t)
		{
			if(t == null)
				return null;
			else
				return new TreeNode { left = CopyTreeShallow(t.left), right = CopyTreeShallow(t.right), data = t.data };
		}
	}

	public class Data { public int val;}
	public class Result { public TreeNode orig; public TreeNode copy;}

	public class Program
	{
		public static object Run()
		{
			TreeNode torig = TreeNode.MakeTree(3);
			TreeNode tcopy = TreeNode.CopyTreeShallow(orig);

			return new Result { orig = torig, copy = tcopy };
		}
	}

HeapDbg/IdX

Could not find sample or program fsm

HeapDbg/HpW

//Create an array of un-aliased and aliased Shperes.
// Each a composite object of an unaliased Point object but a shared Color object.
class Program {
    static object Run() {
        var spheres = new Sphere[10];
        var rgb = new Color { red = 0, blue = 255, green = 0 };
        for (int i = 0; i < 10; ++i) {
            var ctr = new Point { xpos = i, ypos = i + 1, zpos = i - 1 };
            spheres[i] = new Sphere { center = ctr, color = rgb, radius = 3.0F };
        }
spheres[2] = null;
        return new { root = spheres };
    }
}
class Sphere { public Point center; public Color color; public float radius; }
class Color { public int red; public int blue; public int green; }
class Point { public float xpos; public float ypos; public float zpos; }

HeapDbg/iBb

class Etype {} 

class Add:Etype{ public Etype l; public Etype r; }
class Sub:Etype{ public Etype l; public Etype r; }
class Mult:Etype{ public Etype l; public Etype r; }

class Var:Etype{}  
class Const:Etype{}


class Program {
    static object Run() {
              
        Var []env = new Var[3];
        
        Var v1= new Var();
        Var v2= new Var();
        Var v3= new Var();
        
        env[0] = v1;
        env[1] = v2;
        Const c1 = new Const();
        Const c2 = new Const();
       
     

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
                
        var  exp = new Etype();
        exp = ad1; 
        
        return new { root = exp , v = env };
        
        
    }
}

HeapDbg/ib

// Creates an array of un-aliased Data objects
class Data {
  public int variable;
 }
class Program {
    static object Run() {
        var res = new Data[10];
        for (int i = 0; i < res.Length; ++i)
        {
          
        
            Data data = new Data();
            data.variable = 5;
            res[i] = data;
            }
        return new { root = res };
        
        
    }
}

HeapDbg/I7N

// Creates an array of un-aliased Data objects, some entries are null.
class Data { }
class Program {
    static object Run() {         
        var res = new Data[10];
        for (int i = 0; i < 10; ++i) {
            if (i % 2 != 0 && i % 3 != 0)
                res[i] = new Data();
        }
        return new { root = res };
    }
}

HeapDbg/I4

// Creates an array of un-aliased Data objects
class Data { }
class Program {
    static object Run() {
        return "";
    }
}

HeapDbg/I

using System;

class Node { public Node Next; }
public class Program
{
    public static object Run()
    {
        // a list of 3 nodes
        var list = new Node { Next = new Node { Next = new Node() } };
        return list;
    }
}

HeapDbg/P4

// Creates an array of un-aliased Data objects, some entries are null.
class Data { public int Test; }
class Program {
    static object Run() {
        var res = new Data[10];
        for (int i = 0; i < 10; ++i) {
            if (i % 2 != 0 && i % 3 != 0)
                res[i] = new Data() { Test = i};
        }
        return new { root = res, r2 = res[0] };
    }
}

HeapDbg/OX

using System;

class Node { public Node Next; }
public class Program
{
    public static object Run()
    {
        // a list of 3 nodes
        var list = new Node { Next = new Node { Next = new Node() } };
        return list;
    }
}

HeapDbg/CY2

class Etype {} 

class Add:Etype{ public Etype l; public Etype r; }
class Sub:Etype{ public Etype l; public Etype r; }
class Mult:Etype{ public Etype l; public Etype r; }

class Var:Etype{}  
class Const:Etype{}


class Program {
    static object Run() {
              
        Var []env = new Var[3];
        
        Var v1= new Var();
        Var v2= new Var();
        Var v3= new Var();
        
        env[0] = v1;
        env[1] = v2;
        Const c1 = new Const();
        Const c2 = new Const();
       
     

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
                
        Add  exp = new Add();
        exp.l = ad1; 
        
        return new { root = exp , v = env };
        
        
    }
}

HeapDbg/oP

I can't believe I've been going for years without knonwig that.

HeapDbg/cwP

I can't bleieve you're not playing with me--that was so helpful.

HeapDbg/kv

// Creates an array of un-aliased Data objects, some entries are null.
class Data { public int Prop { get; set;} }
class Program {
    static object Run() {
        var res = new Data[10];
        for (int i = 0; i < 10; ++i) {
            if (i % 2 != 0 && i % 3 != 0)
                res[i] = new Data();
        }
        return new { root = res };
    }
}

HeapDbg/E

using System;

class TreeNode 
	{
		public TreeNode left; public TreeNode right; public Data data;

		static TreeNode MakeTree(int k)
		{
			if(k == 0)
				return null;
			else
				return new TreeNode { left = MakeTree(k - 1), right = MakeTree(k - 1), data = new Data() };
		}
	}
	
	class Data { public int val;}

	public class Program
	{
		public static object Run()
		{
			TreeNode res = TreeNode.MakeTree(3);
			return res;
		}
	}

HeapDbg/aY

Thank God! Somonee with brains speaks!

HeapDbg/JeA

class Data { public int val;}
class SpecialData: Data {}
class Program {
    static object Run() {
        var resa = new Data[10];
        var dspecial = new SpecialData();
        for (int i = 0; i < resa.Length; ++i) {
            if (i == 5)
                resa[i] = dspecial;
            else
                resa[i] = new Data();
        }
        return new { array = resa, special = dspecial };
    }
}

HeapDbg/9N

Da9Zk4  <a href="http://pfchtophxxsu.com/">pfchtophxxsu</a>, [url=http://thxboijfnrpr.com/]thxboijfnrpr[/url], [link=http://upjeiqdsacbx.com/]upjeiqdsacbx[/link], http://xmxkxpwwnggs.com/

HeapDbg/6q

// Creates an array of un-aliased Data objects
class Etype { 
  
    public double value;
    Etype pointer;
    public void setValue(double x)
    {
      value = x;
    }
}

class Add:Etype{
  
  public Etype l;
  public Etype r;
  
  
}

class Sub:Etype{
  
  public Etype l;
  public Etype r;
  
}
class Mult:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Data{}
class Var:Etype{
  
  
}
class Const:Etype{}


class Program {
    static object Run() {
              
        Var []env = new Var[3];
        
        Var v1= new Var();
        Var v2= new Var();
        Var v3= new Var();
        
        env[0] = v1;
        env[1] = v2;
        Const c1 = new Const();
        Const c2 = new Const();
       
        

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
                
        exp = new Etype();
        exp.pointer = ad1;
        
        return new { root = exp , v = env };
        
        
    }
}

HeapDbg/6P

Could not find sample or program new

HeapDbg/dt

It's always a relief when soemnoe with obvious expertise answers. Thanks!

HeapDbg/GK

// Creates an array of un-aliased Data objects
class Data { } class Data2 { }
class Program {
    static object Run() {
        var res = new object[10];
        for (int i = 0; i < res.Length; ++i)
            res[i] = i % 2 == 0 ? new Data2(): new Data();
        return new { root = res };
    }
}

HeapDbg/Ub4

// Create an array of aliased Data objects
// Alising is shown as XXX color on [?] edge.
class Data { public int Value; }
class Program {
    static object Run() {
        var res = new Data[10];
        for (int i = 0; i < res.Length; ++i) {
            if (i % 2 == 0)
                res[i] = new Data();
            else
                res[i] = res[i - 1];
        }
        return new { root = res };
    }
}

HeapDbg/3s

iTtMPM  <a href="http://iumuoozyqbyu.com/">iumuoozyqbyu</a>, [url=http://anhjhtbxfhcd.com/]anhjhtbxfhcd[/url], [link=http://ptudfokdxrdz.com/]ptudfokdxrdz[/link], http://ejhetzgwtrsa.com/

HeapDbg/CL

type Event;
type EventType;

const unique MoveMotor : EventType;
const unique TakePhoto : EventType;
const unique MoveAndShoot : EventType;
const unique FetchPhoto : EventType;
const unique WritePhoto : EventType;
const unique FetchAndWrite : EventType;
function typeOf(e : Event) returns (EventType);

type Time = int;
const unique begin : [Event] Time;
const unique end : [Event] Time;
axiom (forall e : Event :: begin[e] <: end[e]);
axiom (forall e1, e2 : Event :: e1 <: e2 <==> begin[e1] <: begin[e2]);

function happens(e : Event, t1, t2 : Time) returns (bool) {
  t1 == begin[e] && t2 == end[e]
}

// true iff e1 contains e2
function contains(parent : Event, child : Event) returns (bool) {
  begin[parent] <: begin[child] && 
    end[child] <: end[parent]
}

function containsSeq(parent : Event, children : [int] Event, n : int) returns (bool) {
  begin[parent] <: begin[children[0]] &&
    end[children[(n - 1)]] <: end[parent]
}

function andThen (e1, e2 : Event) returns (bool) {
    end[e1] <: begin[e2]
}

// create a sequence of events of type "typ"
function repeat (typ : EventType, seq : [int] Event, n : int) returns (bool) {
  n >= 1 &&            // at least one event in the sequence
    typeOf(seq[0]) == typ &&
    typeOf(seq[(n-1)]) == typ &&
    (n > 1 ==>  
     (forall i : int :: 
      (i >= 0 && i < (n - 1)) ==> 
      typeOf(seq[i]) == typ &&
      andThen(seq[i], seq[i+1]))
     )
}

function takePanorama (e : Event, seq : [int] Event, n : int) returns (bool) {
  repeat(MoveAndShoot, seq, n) &&
    containsSeq(e, seq, n)
}

function moveAndShoot (e, e1, e2 : Event) returns (bool) {
  typeOf(e1) == MoveMotor && 
    typeOf(e2) == TakePhoto && 
    andThen(e1, e2) &&
    contains(e, e1) &&
    contains(e, e2)
}

function savePhotos (e : Event, seq : [int] Event, n : int) returns (bool) {
  repeat(FetchAndWrite, seq, n) &&
    containsSeq(e, seq, n)
}

function fetchAndWrite(e, e1, e2 : Event) returns (bool) {
  typeOf(e1) == FetchPhoto && 
    typeOf(e2) == WritePhoto &&
    andThen(e1, e2) &&
    contains(e, e1) &&
    contains(e, e2)
}

function top(e, e1, e2 : Event) returns (bool) {
  contains(e, e1) && contains(e, e2)
}

/**
   Logs
 */
const unique obs : [int] Event;
const unique numObs : int;

const unique panorama1 : Event;
const unique panorama1_seq : [int] Event;
axiom(
      panorama1_seq[0] == moveShoot1 &&
      panorama1_seq[1] == moveShoot2 &&
      panorama1_seq[2] == moveShoot3
      );

const unique moveShoot1 : Event;
const unique move1 : Event;
const unique take1 : Event;
const unique moveShoot2 : Event;
const unique move2 : Event;
const unique take2 : Event;
const unique moveShoot3 : Event;
const unique move3 : Event;
const unique take3 : Event;

const unique savePhotos1 : Event;
const unique savePhotos1_seq : [int] Event;
axiom(
      savePhotos1_seq[0] == fetchWrite1
      );

const unique fetchWrite1 : Event;
const unique fetch1 : Event;
const unique write1 : Event;

const unique top : Event;

axiom(
      takePanorama(panorama1, panorama1_seq, 3) &&
      moveAndShoot(moveShoot1, move1, take1) &&
      moveAndShoot(moveShoot2, move2, take2) &&
      moveAndShoot(moveShoot3, move3, take3) &&
      savePhotos(savePhotos1, savePhotos1_seq, 1) &&
      fetchAndWrite(fetchWrite1, fetch1, write1) &&
      top(top, panorama1, savePhotos1)
      );

axiom(numObs == 11);
// event order in the log
axiom(
      /*
      obs[0] == top &&
      obs[1] == panorama1 &&
      obs[2] == moveShoot1 &&
      obs[3] == move1 &&
      obs[4] == take1 &&
      obs[5] == moveShoot2 &&
      obs[6] == move2 &&
      obs[7] == take2 &&
      obs[8] == moveShoot3 &&
      obs[9] == move3 &&
      obs[10] == take3
      */

      obs[0] == top &&
      obs[1] == panorama1 &&
      obs[2] == moveShoot1 &&
      obs[3] == move1 &&
      obs[4] == take1 &&
      obs[5] == savePhotos1 &&
      obs[6] == fetchWrite1 &&
      obs[7] == fetch1 &&
      obs[8] == moveShoot2 &&
      obs[9] == move2 &&
      obs[10] == write1 &&
      obs[11] == take2 &&
      obs[12] == moveShoot3 &&
      obs[13] == move3 &&
      obs[14] == take3
      );

function traceConforms(concTrace : [int] Event, length : int) returns (bool) {
  (forall i, j : int :: 
   (i >= 0 && j < length && i < j) ==>
   !(concTrace[j] <: concTrace[i]) 
   )
}

procedure move() 
  modifies motorPosition;
{
  var newPos : Position;
 motorPosition := newPos;  
}

procedure takePhoto()
  modifies photosTaken;
{
 photosTaken := photosTaken[photos[motorPosition] := true];
}

procedure fetchPhoto()
  modifies photoFetched, photosTaken;
{
  var p : Photo;
  assume(photosTaken[p]);
 photoFetched := p;
 photosTaken := photosTaken[p := false];
}

procedure savePhoto()
  modifies photosSaved;
{
 photosSaved := photosSaved[photoFetched := true];
}

procedure Main() 
  modifies motorPosition, photosTaken, photoFetched, photosSaved;
{ 
  var t1, t2 : Time;
  assume(happens(top, t1, t2));
  assert(!traceConforms(obs, numObs));
  assume(forall p : Photo :: !(photosTaken[p]));
  assume(forall p : Photo :: !(photosSaved[p]));
  call move();
  call takePhoto();
  call fetchPhoto();
  call move();
  call savePhoto();
  call takePhoto();
  call move();
  call takePhoto();
  assert(exists p : Photo :: photosSaved[p]);
}

/**
   Sytem state
*/
type Position;
type Photo;

var motorPosition : Position;
var photosTaken : [Photo] bool;
var photoFetched : Photo;
var photosSaved : [Photo] bool;

/**
   Environment
*/
const unique photos : [Position] Photo;

/*
// partial order relation between events
const unique trace : [Event, Event] bool;
// reflexive
axiom(forall e : Event :: trace[e, e]);
// antisymmetric
axiom(forall e1, e2 : Event :: (trace[e1, e2] && trace[e2, e1]) ==> e1 == e2);
// transitive
axiom(forall e1, e2, e3 : Event :: (trace[e1, e2] && trace[e2, e3]) ==> trace[e1, e3]);
*/

HeapDbg/0r

// Creates an array of un-aliased Data objects
public class Data { public int val; public Data left; public Data right; }
class Program {
    static object Run() {
        var res = new Data[10];
        for (int i = 0; i < res.Length; ++i)
        { 
            var d=new Data();  
            d.left=new Data();
            res[i] = d;
        }
        return new { root = res };
    }
}

HeapDbg/sLhI

class Etype {public Etype points;} 

class Add:Etype{ public Etype l; public Etype r; }
class Sub:Etype{ public Etype l; public Etype r; }
class Mult:Etype{ public Etype l; public Etype r; }

class Var:Etype{}  
class Const:Etype{}


class Program {
    static object Run() {
              
        Var []env = new Var[3];
        
        
        
        Var v1= new Var();
        Var v2= new Var();
        Var v3= new Var();
        
        env[0] = v1;
        env[1] = v2;
        Const c1 = new Const();
        Const c2 = new Const();
       
     

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
        Add exp = new Add();
        exp.l = ad1;
        return new { exp , env };
        
        
    }
}

HeapDbg/slh

Hats off to whoeevr wrote this up and posted it.

HeapDbg/Hp

// Creates a heap and returns each root as a field of the return object
class Hello { public World World; }
class World { }
class Program {
    static object Run() {
        var res = new Hello { World = new World() };
        return new { root = res };
    }
}

HeapDbg/ot

// Creates a heap and returns each root as a field of the return object
class Hello { public World World; }
class World { }
class Program {
    static object Run() {
        var res = new Hello { World = new World() };
        return new { root = res };
    }
}audi

HeapDbg/sl

using System;

class Hello { public World World; }
class World { }
public class Program
{
    public static object Run()
    {
        return new Hello { World = new World() };
    }
}

HeapDbg/sG

Whoa, things just got a whole lot esiaer.

HeapDbg/sFe

// Creates an array of un-aliased Data objects
class Data { }
class Program {
    static object Run() {
        var res = new System.Collections.Generic.List<Data>(80000);
        for (int i = 0; i < res.Count; ++i)
            res[i] = new Data();
        return new { root = res };
    }
}

HeapDbg/nc

UN3X0z  <a href="http://clodaphtesds.com/">clodaphtesds</a>, [url=http://tnqdsbpmljpv.com/]tnqdsbpmljpv[/url], [link=http://mqbbajbjkebs.com/]mqbbajbjkebs[/link], http://sivdytdmzfve.com/

HeapDbg/N8

// Creates an array of un-aliased Data objects
class Data {
  
  public  string getDeviceID()
  {
    return "12";
  }
 }
 
 class Test
 {
   
   public void print(string s)
   {
     
     string d = s;
   }
   
 }
 
class Program {
    static object Run() {
        var res = new Data();
        var ob = new Test();
        //for (int i = 0; i < res.Length; ++i)
        string s = res.getDeviceID()+ "desh";
           
        ob.print(s);   
        return new { root = s };
    }
}

HeapDbg/N

using System;

class ListNode { public ListNode next; }
public class Program
{
    public static object Run()
    {
ListNode res = null;

for(int i = 0; i < 10; ++i)
res = new ListNode {next = res};

return res;
    }
}

HeapDbg/mZ

// Creates an array of un-aliased Data objects
class Etype { 
  
    public double value;
    public void setValue(double x)
    {
      value = x;
    }
}

class Add:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Sub:Etype{
  
  public Etype l;
  public Etype r;
  
}
class Mult:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Data{}
class Var:Etype{}
class Const:Etype{}


class Program {
    static object Run() {
        var res = new Data[10];
        
              
        Var []env = new Var[3];
        Var v1,v2;
        env[0] = v1;
        env[0] = v2;
        
        Const c1 = new Const();
        Const c2 = new Const();
       
        

        Sub sb  = new Sub();
        sb.r = env[0];
        sb.l = env[1];
        
        Add ad2 = new Add();
        ad2.l = env[1];
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
        var exp = ad1;        
        
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
        return new { root = exp , variable = env };
        
        
    }
}

HeapDbg/muH

class Etype {} 

class Add:Etype{ public Etype l; public Etype r; }
class Sub:Etype{ public Etype l; public Etype r; }
class Mult:Etype{ public Etype l; public Etype r; }

class Var:Etype{}  
class Const:Etype{}


class Program {
    static object Run() {
              
        Var []env = new Var[3];
        
        Var v1= new Var();
        Var v2= new Var();
        Var v3= new Var();
        
        env[0] = v1;
        env[1] = v2;
        Const c1 = new Const();
        Const c2 = new Const();
       
     

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
                
        
        return new { ad1 , env };
        
        
    }
}

HeapDbg/PP

// Creates an array of un-aliased Data objects
class Data { private int prop; }
class Program {
    static object Run() {
        var res = new Data[10];
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
        return { root = new Data() };//res };
    }
}

HeapDbg/mQ

class Etype {} 

class Add:Etype{ public Etype l; public Etype r; }
class Sub:Etype{ public Etype l; public Etype r; }
class Mult:Etype{ public Etype l; public Etype r; }

class Var:Etype{}  
class Const:Etype{}


class Program {
    static object Run() {
              
        Var []env = new Var[3];
        
        
        
        Var v1= new Var();
        Var v2= new Var();
        Var v3= new Var();
        
        env[0] = v1;
        env[1] = v2;
        Const c1 = new Const();
        Const c2 = new Const();
       
     

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
        Add exp = new Add();        
        exp.l = ad1;
        return new { exp , env };
        
        
    }
}

HeapDbg/mpn

// Creates a heap and returns each root as a field of the return object
class Hello { public World World; 

              public int getId()
              {
                return 100;
              }
}
class World { }

class Program {
    static object Run() {
      
        int id;
        
        var res = new Hello { World = new World() };
        id = res.getId();
        return new { root = res };
    }
}

HeapDbg/Hqs

// Creates an array of un-aliased Data objects
class Etype { 
  
    public double value;
    public void setValue(double x)
    {
      value = x;
    }
    public double getValue()
    {
      return value;
    }
  }

class Add:Etype{
  
  Etype l;
  Etype r;
  double getVal()
  {
    return (l.getValue()+r.getValue());    
  }
}

class Data{}
class Var:Etype{
   
}

class Const:Etype{
   
}


class Program {
    static object Run() {
        var res = new Data[10];
        
        Var []env = new Var[3];
        Const c1 = new Const();
        Const c2 = new Const();
        c1.setValue(5);
        c1.setValue(6);
        
        
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
        return new { root = res };
        
        
    }
}

HeapDbg/HO

class Eobjects{}
class Etype:Eobjects {public Etype pointsto;} 

class Add:Etype{ public Eobjects l; public Eobjects r; }
class Sub:Etype{ public Eobjects l; public Eobjects r; }
class Mult:Etype{ public Eobjects l; public Eobjects r; }

class Var:Eobjects{}  
class Const:Eobjects{}


class Program {
    
    static object test(Etype exp, Var [] env)
    {
      
      return new { exp , env };
    }
    static object Run() {
              
        Var []env = new Var[3];
        
        
        
        Var v1= new Var();
        Var v2= new Var();
        Var v3= new Var();
        
        env[0] = v1;
        env[1] = v2;
        Const c1 = new Const();
        Const c2 = new Const();
       
     

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
        Etype exp = new Etype();
        exp.pointsto = ad1;
        return new { ad1 , env };
        
     
       
    }
}

HeapDbg/hnP

// Creates an array of un-aliased Data objects
class Etype { 
  
    public Etype l;
  public Etype r;
  
    public double value;
    public void setValue(double x)
    {
      value = x;
    }
}

class Add:Etype{
  
  
  
}

class Sub:Etype{
  
  public Etype l;
  public Etype r;
  
}
class Mult:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Data{}
class Var:Etype{
  
  
}
class Const:Etype{}


class Program {
    static object Run() {
              
        Var []env = new Var[3];
        
        Var v1= new Var();
        Var v2= new Var();
        Var v3= new Var();
        
        env[0] = v1;
        env[1] = v2;
        Const c1 = new Const();
        Const c2 = new Const();
       
        

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
                
        Add exp = new Add();
        exp.l = ad1;
        
        return new { root = exp , v = env };
        
        
    }
}

HeapDbg/EvcM

// Creates an array of un-aliased Data objects
class Etype { 
  
    public double value;
    public void setValue(double x)
    {
      value = x;
    }
}

class Add:Etype{
  
  public Etype l;
  public Etype r;
  
  
}

class Sub:Etype{
  
  public Etype l;
  public Etype r;
  
}
class Mult:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Data{}
class Var:Etype{
  
  
}
class Const:Etype{}


class Program {
    static object Run() {
              
        Var []env = new Var[3];
        
        Var v1= new Var();
        Var v2= new Var();
        Var v3= new Var();
        
        env[0] = v1;
        env[1] = v2;
        Const c1 = new Const();
        Const c2 = new Const();
       
        

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
                
        Etype exp = ad1;
        
        return new { root = exp , v = env };
        
        
    }
}

HeapDbg/cVu

// Creates an array of un-aliased Data objects
class Data { }
class Program {
    static object Run() {
        var res = new List<Data>(80000);
        for (int i = 0; i < res.Count; ++i)
            res[i] = new Data();
        return new { root = res };
    }
}

HeapDbg/Cs

class Etype {} 

class Add:Etype{ public Etype l; public Etype r; }
class Sub:Etype{ public Etype l; public Etype r; }
class Mult:Etype{ public Etype l; public Etype r; }

class Var:Etype{}  
class Const:Etype{}


class Program {
    static object Run() {
              
        Var []env = new Var[3];
        
        Var v1= new Var();
        Var v2= new Var();
        Var v3= new Var();
        
        env[0] = v1;
        env[1] = v2;
        Const c1 = new Const();
        Const c2 = new Const();
       
     

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
                
        Add  exp = ad1;
        
        
        return new { exp , env };
        
        
    }
}

HeapDbg/cQ

// Creates an array of un-aliased Data objects
class Etype { 
  
    public double value;
    public void setValue(double x)
    {
      value = x;
    }
    public double getValue()
    {
      return value;
    }
  }

class Add:Etype{
  
  Etype l;
  Etype r;
  double getVal()
  {
    return (l.getValue()+r.getValue());    
  }
}

class Data{}
class Var:Etype{
   
}

class Program {
    static object Run() {
        var res = new Data[10];
        
        Var []env = new Var[3];
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
        return new { root = res };
        
        
    }
}

HeapDbg/k

using System;

class ListNode { public ListNode next; }
class Data {public int val;}
public class Program
{
    public static object Run()
    {
ListNode res = null;

for(int i = 0; i < 10; ++i)
res = new ListNode {next = res, val = new Data()};

return res;
    }
}

HeapDbg/9F

// Creates an array of un-aliased Data objects
class Data { }
class Program {
    static object Run() {
        var res = new Data[10];
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
        return new { root = res };
    }
}

HeapDbg/6hG

class Etype {} 

class Add:Etype{ public Etype l; public Etype r; }
class Sub:Etype{ public Etype l; public Etype r; }
class Mult:Etype{ public Etype l; public Etype r; }

class Var:Etype{}  
class Const:Etype{}


class Program {
    static object Run() {
              
        Var []env = new Var[3];
        
        Etype exp = new Etype;
        
        Var v1= new Var();
        Var v2= new Var();
        Var v3= new Var();
        
        env[0] = v1;
        env[1] = v2;
        Const c1 = new Const();
        Const c2 = new Const();
       
     

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
                
        exp = ad1;
        return new { exp , env };
        
        
    }
}

HeapDbg/6F

// Creates an array of un-aliased Data objects

class Eobjects{
  
 Etype pointer;
  
}

class Etype:Eobjects { 
  
    public double value;
    
    public void setValue(double x)
    {
      value = x;
    }
}

class Add:Etype{
  
  public Etype l;
  public Etype r;
  
  
}

class Sub:Etype{
  
  public Etype l;
  public Etype r;
  
}
class Mult:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Data{}
class Var:Eobjects{
  
  
}
class Const:Eobjects{}


class Program {
    static object Run() {
              
        Var []env = new Var[3];
        
        Var v1= new Var();
        Var v2= new Var();
        Var v3= new Var();
        
        env[0] = v1;
        env[1] = v2;
        Const c1 = new Const();
        Const c2 = new Const();
       
        

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
                
        Eobjects  exp = new Eobjects();
        exp.pointer  = (Etype)ad1; 
        
        return new { root = exp , v = env };
        
        
    }
}

HeapDbg/FhZ

// Create a LinkedList of Data objects
// Self edge on, Next, and label, List
class Data { }
class X: Data { }
class Y: Data { }
class ListNode { public ListNode Next, Prev; public Data Data; }
class Program {
    static object Run() {
        ListNode res = null;
        for (int i = 0; i < 10; ++i) {
            res = new ListNode { Next = res, Data = new X() };
        }
        return new { root = res };
    }
}

HeapDbg/cO

// Creates an array of un-aliased Data objects, some entries are null.
class Data { }
class Program {
    static object Run() {
        var res = new Data[10];
        for (int i = 0; i < 10; ++i) {
            if (i % 2 != 0 && i % 3 != 0)
                res[i] = new Data();
        }
        return new { root = res };
    }
}

HeapDbg/tw

// Creates an array of un-aliased Data objects, some entries are null.
public class Program
    {
        Program f;
        public static object Run()
        {
            Program param = new Program();
            Program local1 = bar();
            Program local2 = bar();
            local1.f = param;
            local2.f = new Program();
            local2.f.f = new Program();
            return  local1;
        }

        public static Program bar()
        {
            Program r = new Program();
            return r;
        }
    }

HeapDbg/tsL

class Etype {} 

class Add:Etype{ public Etype l; public Etype r; }
class Sub:Etype{ public Etype l; public Etype r; }
class Mult:Etype{ public Etype l; public Etype r; }

class Var:Etype{}  
class Const:Etype{}


class Program {
  
    static object test(){
      
      
      Var []env = new Var[3];
        
        
        
        Var v1= new Var();
        Var v2= new Var();
        Var v3= new Var();
        
        env[0] = v1;
        env[1] = v2;
        Const c1 = new Const();
        Const c2 = new Const();
       
     

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
        Etype exp = new Etype();         
        exp = ad1;
        return new { exp , env }; 
      
    }
    
    static void Run() {
              
     object ob = test();
     return ob;  
    }
}

HeapDbg/Tp

// Creates an array of un-aliased Data objects
import java.lang.*;

public class Hello{
   public static void main(String[]args){
      System.out.println("Hello");
   }
}

HeapDbg/tn

// Creates an array of un-aliased Data objects

class Program {
    static object Run() {
        return new Object();
    }
}

HeapDbg/tM

// Creates an array of un-aliased Data objects
class Data {
  
  public  string getDeviceID()
  {
    return "12";
  }
 }
 
 class Test
 {
   
   public void print(string s)
   {
     
     string d = s;
   }
   
 }
 
class Program {
    static object Run() {
        var res = new Data();
        var ob = new Test();
        //for (int i = 0; i < res.Length; ++i)
        string s = res.getDeviceID()+ "desh";
           
        ob.print(s);   
        return new { root = res };
    }
}

HeapDbg/TL

// Creates an array of un-aliased Data objects
class Etype { 
  
    public double value;
    Etype pointer;
    public void setValue(double x)
    {
      value = x;
    }
}

class Add:Etype{
  
  public Etype l;
  public Etype r;
  
  
}

class Sub:Etype{
  
  public Etype l;
  public Etype r;
  
}
class Mult:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Data{}
class Var:Etype{
  
  
}
class Const:Etype{}


class Program {
    static object Run() {
              
        Var []env = new Var[3];
        
        Var v1= new Var();
        Var v2= new Var();
        Var v3= new Var();
        
        env[0] = v1;
        env[1] = v2;
        Const c1 = new Const();
        Const c2 = new Const();
       
        

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
                
        Etype exp = new Etype();
        exp.pointer = ad1;
        
        return new { root = exp , v = env };
        
        
    }
}

HeapDbg/Ti8

// Creates an array of un-aliased Data objects
class Data { value = 3 }
class Program {
    static object Run() {
        var res = new Data[10];
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
        return new { root = res };
    }
}

HeapDbg/KD

using System;

public class Program
	{
		public static object Run()
		{
			Data[] res = new Data[10];

			for(int i = 0; i < 10; ++i)
			{
				if(i % 2 != 0 && i % 3 != 0)
					res[i] = new Data();
			}

			return res;
		}
	}

	public class Data { public int val;}

HeapDbg/oW

// Create a LinkedList of Data objects
// Self edge on, Next, and label, List
class Data { }
class X: Data { }
class ListNode { public ListNode Next; public Data Data; }
class Program {
    static object Run() {
        ListNode res = null;
        for (int i = 0; i < 10; ++i)
            res = new ListNode { Next = res, Data = new Data() };
        return new { root = res };
    }
}

HeapDbg/oT3

Keep it coinmg, writers, this is good stuff.

HeapDbg/oNT

class Etype {} 

class Add:Etype{ public Etype l; public Etype r; }
class Sub:Etype{ public Etype l; public Etype r; }
class Mult:Etype{ public Etype l; public Etype r; }

class Var:Etype{}  
class Const:Etype{}


class Program {
    static object Run(Etype exp) {
              
        Var []env = new Var[3];
        
        
        
        Var v1= new Var();
        Var v2= new Var();
        Var v3= new Var();
        
        env[0] = v1;
        env[1] = v2;
        Const c1 = new Const();
        Const c2 = new Const();
       
     

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
                
        exp = ad1;
        return new { exp , env };
        
        
    }
}

HeapDbg/on

// Creates a heap and returns each root as a field of the return object
class Hello { public World World; }
class World { }
public class Program
    {
        Program f;
        int h;
        public void foo(Program param)
        {
            Program local1 = bar();
            Program local2 = bar();
            local1.f = param;
            local2.f = new Program();
            local2.f.h = 1;
        }

        public Program bar()
        {
            Program r = new Program();
            return r;
        }
    }

HeapDbg/PpP

// Creates an array of un-aliased Data objects
class Data { public string Prop {get; set;} }
class Program {
    static object Run() {
        var res = new Data[10];
        for (int i = 0; i < res.Length; ++i) {
            res[i] = new Data() { Prop = "wow" };

        }
        return new { root = res };
    }
}

HeapDbg/Oe

Could not find sample or program ArrayOfSameColorSphereObjects01

HeapDbg/oB

using System;

// Creates an array of un-aliased Data objects
class Data {
  
  public  string getDeviceID()
  {
    return "12";
  }
 }
 
 class Test
 {
   
   public void print(string s)
   {
     
     string d = s;
   }
   
 }
 
class Program {
    static object Run() {
        var res = new Data();
        var ob = new Test();
        //for (int i = 0; i < res.Length; ++i)
        string s = res.getDeviceID();
           
        string s2 = s + "desh"; 
        
        Random rnd = new Random();  
        ob.print(s2);   
        return new { root = res };
    }
}

HeapDbg/JC

// Creates a Deep Copy of a Tree of Data objects
class Data { public int Value;}
class TreeNode {
    public TreeNode Left; public TreeNode Right; 
    public Data Data;
    public static TreeNode MakeTree(int k) {
        if (k == 0)
            return null;
        else
            return new TreeNode { 
                Left = MakeTree(k - 1), Right = MakeTree(k - 1), 
                Data = new Data() 
            };
    }
    public static TreeNode CopyTreeDeep(TreeNode t) {
        if (t == null)
            return null;
        else
            return new TreeNode { 
                Left = CopyTreeDeep(t.Left), Right = CopyTreeDeep(t.Right), 
                Data = new Data { val = t.Data.Value } 
            };
    }
}
class Program {
    static object Run() {
        var original = TreeNode.MakeTree(3);
        var copy = TreeNode.CopyTreeDeep(torig);

        return new { orig = original, copy = copy };
    }
}

HeapDbg/J6

TO7VXV  <a href="http://czgbmiksifyq.com/">czgbmiksifyq</a>, [url=http://ivogrrfaeotg.com/]ivogrrfaeotg[/url], [link=http://stizwpiypsic.com/]stizwpiypsic[/link], http://gzcykpwtipjn.com/

HeapDbg/j2

// Creates an array of un-aliased Data objects

class Eobjects{
  
 Etype pointer;
  
}

class Etype:Eobjects { 
  
    public double value;
    
    public void setValue(double x)
    {
      value = x;
    }
}

class Add:Etype{
  
  public Etype l;
  public Etype r;
  
  
}

class Sub:Etype{
  
  public Etype l;
  public Etype r;
  
}
class Mult:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Data{}
class Var:Etype{
  
  
}
class Const:Etype{}


class Program {
    static object Run() {
              
        Var []env = new Var[3];
        
        Var v1= new Var();
        Var v2= new Var();
        Var v3= new Var();
        
        env[0] = v1;
        env[1] = v2;
        Const c1 = new Const();
        Const c2 = new Const();
       
        

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
                
        Eobjects  exp = new Eobjects();
        exp.pointer  = ad1; 
        
        return new { root = exp , v = env };
        
        
    }
}

HeapDbg/J1

// Creates an array of un-aliased Data objects
class Etype { 
  
    public Etype l;
    public Etype r;
  
    public double value;
    public void setValue(double x)
    {
      value = x;
    }
}

class Add:Etype{
  
  
  
}

class Sub:Etype{
  
}
class Mult:Etype{
  
}

class Data{}
class Var:Etype{
  
  
}
class Const:Etype{}


class Program {
    static object Run() {
              
        Var []env = new Var[3];
        
        Var v1= new Var();
        Var v2= new Var();
        Var v3= new Var();
        
        env[0] = v1;
        env[1] = v2;
        Const c1 = new Const();
        Const c2 = new Const();
       
        

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
                
        Add exp = new Add();
        exp.l = ad1;
        
        return new { root = exp , v = env };
        
        
    }
}

HeapDbg/J

using System;

public class Result { public STreeNode tree; public Color scolor;}

	public class Program
	{
		public static object Run()
		{
			Color special = new Color { red = 0, blue = 255, green = 0 };
			STreeNode rtn = STreeNode.MakeTree(3, special);

			return new Result { tree = rtn, scolor = special };
		}
	}
	public class STreeNode
	{
		public STreeNode left; public STreeNode right; public Sphere[] data;

		public static STreeNode MakeTree(int k, Color c)
		{
			if(k == 0)
				return null;
			else
			{
				Sphere[] sph = new Sphere[5];
				for(int i = 0; i < 5; ++i)
					sph[i] = new Sphere { center = new Point { xpos = k, ypos = k, zpos = k }, color = c, radius = 1F };
			
				return new STreeNode { left = MakeTree(k - 1, c), right = MakeTree(k - 1, c), data = sph };
			}
		}
	}

	public class Sphere { public Point center; public Color color; public float radius; }
	public class Color { public int red; public int blue; public int green; }
	public class Point { public float xpos; public float ypos; public float zpos; }

HeapDbg/IvO

class Etype {} 

class Add:Etype{ public Etype l; public Etype r; }
class Sub:Etype{ public Etype l; public Etype r; }
class Mult:Etype{ public Etype l; public Etype r; }

class Var:Etype{}  
class Const:Etype{}


class Program {
    static object Run() {
              
        Var []env = new Var[3];
        
        Var v1= new Var();
        Var v2= new Var();
        Var v3= new Var();
        
        env[0] = v1;
        env[1] = v2;
        Const c1 = new Const();
        Const c2 = new Const();
       
     

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
                
        Add  exp = new Add();
        exp.l = ad1; 
        
        return new { ad1 , env };
        
        
    }
}

HeapDbg/Iv

// Creates an array of un-aliased Data objects
class Data { int a,b,c; }
class Program {
    static object Run() {
        var res = new Data[10,10];
        for (int i = 0; i < 10; ++i)
            res[i,0] = new Data[10];
        return new { root = res };
    }
}

HeapDbg/PL7

// Creates an array of un-aliased Data objects, some entries are null.
class Data { }
class Program {
    static object Run() {
  
        var res = new Data[10];
//        for (int i = 0; i < 10; ++i) {
            if (i % 2 != 0 && i % 3 != 0)
                res[i] = new Data();
//        }
        return new { root = res };
    }
}

HeapDbg/d2

// Creates an array of un-aliased Data objects, some entries are null.
class Data { }
class Program {
    static object Run() {
        var res = new Data[10];
        for (int i = 0; i < 10; ++i) {
            if (i % 2 != 0 && i % 3 != 0)
                res[i] = new Data();
        }
        return new { root = res;lol=res };
    }
}

HeapDbg/BGm

// Creates an array of un-aliased Data objects
class Data {
  
  public  string getDeviceID()
  {
    return "12";
  }
 }
 
 class Test
 {
   
   public void print(string s)
   {
     
     string d = s;
   }
   
 }
 
class Program {
    static object Run() {
        var res = new Data();
        var ob = new Test();
        //for (int i = 0; i < res.Length; ++i)
        string s = res.getDeviceID();
           
        ob.print(s);   
        return new { root = res };
    }
}

HeapDbg/bF

// Creates an array of un-aliased Data objects
class Etype { 
  
    public double value;
    public void setValue(double x)
    {
      value = x;
    }
}

class Add:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Sub:Etype{
  
  public Etype l;
  public Etype r;
  
}
class Mult:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Data{}
class Var:Etype{}
class Const:Etype{}


class Program {
    static object Run() {
              
        Var []env = new Var[3];
        Var v1 = null;
        Var v2 = null;
        
        v1 = env[0];
        v2 = env[1];
        
        Const c1 = new Const();
        Const c2 = new Const();
       
        

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
        var exp = ad1;        
        
        
        return new { root = exp , v = env };
        
        
    }
}

HeapDbg/kE

Gee willikres, that's such a great post!

HeapDbg/A1

class Etype {} 

class Add:Etype{ public Etype l; public Etype r; }
class Sub:Etype{ public Etype l; public Etype r; }
class Mult:Etype{ public Etype l; public Etype r; }

class Var:Etype{}  
class Const:Etype{}


class Program {
    static object Run() {
              
        Var []env = new Var[3];
        
        Var v1= new Var();
        Var v2= new Var();
        Var v3= new Var();
        
        env[0] = v1;
        env[1] = v2;
        Const c1 = new Const();
        Const c2 = new Const();
       
     

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
                
        Add  exp = new Add();
        exp.l = ad1; 
        
        return new { exp = ad1,exp = sb , env };
        
        
    }
}

HeapDbg/3Z

// Create a LinkedList of Data objects
// Self edge on, Next, and label, List
class Data { }
class ListNode { public ListNode Next,Prev; public Data Data; }
class Program {
    static object Run() {
        ListNode res = null;
        for (int i = 0; i < 10; ++i) {
            res = new ListNode { Next = res, Data = new Data() };
            if (res.Next != null) {
            res.Next.Prev = res;
            }
        }
        return new { root = res };
    }
}

HeapDbg/2O

// Creates an array of un-aliased Data objects
class Data { }
class Program {
    static object Run() {
        return 1;
    }
}

HeapDbg/18

using System;

class Hello { public World World; }
class World { }
public class Program
{
    public static object Run()
    {
        return new [] {new  Hello { World = new World() },new  Hello { World = new World() }};
    }
}

HeapDbg/0ux

// Create a LinkedList of Data objects
// Self edge on, Next, and label, List
class Data { }
class X: Data { }
class Y: Data { }
class ListNode { public ListNode Next, Prev; public Data Data; }
class Program {
    static object Run() {
        ListNode res = null;
        for (int i = 0; i < 10; ++i) {
            res = new ListNode { Next = res, Data = new X() };
            res.Next.Prev = null;
        }
        return new { root = res };
    }
}

HeapDbg/wqi

class Etype {} 

class Add:Etype{ public Etype l; public Etype r; }
class Sub:Etype{ public Etype l; public Etype r; }
class Mult:Etype{ public Etype l; public Etype r; }

class Var:Etype{}  
class Const:Etype{}


class Program {
    static object Run() {
              
        Var []env = new Var[3];
        object exp = new object();
        
        
        Var v1= new Var();
        Var v2= new Var();
        Var v3= new Var();
        
        env[0] = v1;
        env[1] = v2;
        Const c1 = new Const();
        Const c2 = new Const();
       
     

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
                
        exp = ad1;
        return new { exp , env };
        
        
    }
}

HeapDbg/W8

// Creates an array of un-aliased Data objects
class Data2 { }
class Program {
    static object Run() {
        var res = new Data[10];
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
        return new { root = res };
    }
}

HeapDbg/vY7

// Creates an array of un-aliased Data objects
class Data {
  public int variable;
 }
class Program {
    static object Run() {
        var res = new Data[10];
        for (int i = 0; i < res.Length; ++i)
            Data data = new Data();
            data.variable = 5;
            res[i] = data;
        return new { root = res };
        
        
    }
}

HeapDbg/qu

// Creates an array of un-aliased Data objects
class Etype { 
  
    public double value;
    public void setValue(double x)
    {
      value = x;
    }
}

class Add:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Sub:Etype{
  
  public Etype l;
  public Etype r;
  
}
class Mult:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Data{}
class Var:Etype{}
class Const:Etype{}


class Program {
    static object Run() {
        var res = new Data[10];
        
              
        Var []env = new Var[3];
        Const c1 = new Const();
        Const c2 = new Const();
       
        

        Sub sb  = new Sub();
        sb.r = env[0];
        sb.l = env[1];
        
        Add ad2 = new Add();
        ad2.l = env[1];
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
        var exp = ad1;        
        
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
        return new { root = exp , variable = env };
        
        
    }
}

HeapDbg/qp

// Create an array of un-aliased Shperes.
// Each a composite object of an unaliased Point object and Color object
class Color { public int red; public int blue; public int green; }
class Point { public float xpos; public float ypos; public float zpos; }
class Sphere { 
    public Point center; 
    public Color color; 
    public float radius; 
}
class Program {
    static object Run() {
        var spheres = new Sphere[10];
        for (int i = 0; i < spheres.Length; ++i) {
            var ctr = new Point { xpos = i, ypos = i + 1, zpos = i - 1 };
            var rgb = new Color { red = i, blue = i, green = i };
            spheres[i] = new Sphere { center = ctr, color = rgb, radius = 3.0F };
        }
        return new { spheres = spheres };
    }
}

HeapDbg/qplH

class Etype {} 

class Add:Etype{ public Etype l; public Etype r; }
class Sub:Etype{ public Etype l; public Etype r; }
class Mult:Etype{ public Etype l; public Etype r; }

class Var:Etype{}  
class Const:Etype{}


class Program {
    static object Run() {
              
        Var []env = new Var[3];
        
        
        
        Var v1= new Var();
        Var v2= new Var();
        Var v3= new Var();
        
        env[0] = v1;
        env[1] = v2;
        Const c1 = new Const();
        Const c2 = new Const();
       
     

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
        Etype exp = new Etype();        
        exp = ad1;
        return new { exp , env };
        
        
    }
}

HeapDbg/Qpl7

// Creates an array of un-aliased Data objects
using System;
namespace HelloWorld
{
    class Hello 
    {
        static void Main() 
        {
        }
    }
}

HeapDbg/Qk

class Etype {public double value;} 

class Add:Etype{ public Etype l; public Etype r; }
class Sub:Etype{ public Etype l; public Etype r; }
class Mult:Etype{ public Etype l; public Etype r; }

class Var:Etype{}  
class Const:Etype{}


class Program {
    static object Run() {
              
        Var []env = new Var[3];
        
        Etype exp = new Etype();
        
        Var v1= new Var();
        Var v2= new Var();
        Var v3= new Var();
        
        env[0] = v1;
        env[1] = v2;
        Const c1 = new Const();
        Const c2 = new Const();
       
     

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
                
        exp = ad1;
        return new { exp , env };
        
        
    }
}

HeapDbg/qf


// Creates an array of un-aliased Data objects
class Data {
  
  public  string getDeviceID()
  {
    return "12";
  }
 }
 
 class Test
 {
   
   public void print(string s, int n)
   {
     string d; 
     if(n>5)
      d = s;
     else
      d = ""; 
   }
   
 }
 
class Program {
    static object Run() {
        var res = new Data();
        var ob = new Test();
        //for (int i = 0; i < res.Length; ++i)
        string s = res.getDeviceID();
           
        string s2 = s + "desh"; 
        int k = 8;
        ob.print(s2,k);   
        return new { root = res };
    }
}

HeapDbg/qeI

// Creates an array of un-aliased Data objects
class Etype { 
  
    public double value;
    public void setValue(double x)
    {
      value = x;
    }
}

class Add:Etype{
  
  public Etype l;
  public Etype r;
  
  
}

class Sub:Etype{
  
  public Etype l;
  public Etype r;
  
}
class Mult:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Data{}
class Var:Etype{
  
  public Etype arrayIndex;
}
class Const:Etype{}


class Program {
    static object Run() {
              
        Var []env = new Var[3];
        
        Var v1 = new Var();
        Var v2 = new Var();
        
        env[0].arrayIndex = v1;
        env[0].arrayIndex = v2;
        
        Const c1 = new Const();
        Const c2 = new Const();
       
        

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
        var exp = ad1;        
        
        
        return new { root = exp , v = env };
        
        
    }
}

HeapDbg/QdG

// Creates an array of un-aliased Data objects
class Data { }
class Program {
    static object Run() {
        var res = new Data[11];
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();        res[10] = 7829;
        return new { root = res };
    }
}

HeapDbg/q3

// Creates an array of un-aliased Data objects
class Data { 
  
  public string getDeviceID()
  {
       return "121";
  }
}


class Program {
    static void Run() {
        string val;
        var res = new Data[10];
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
            
        val = res[0].getDeviceID();            
        //return new {root = res };
    }
}

HeapDbg/PYq

// Creates an array of un-aliased Data objects
class Etype { 
  
    public double value;
    public void setValue(double x)
    {
      value = x;
    }
}

class Add:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Sub:Etype{
  
  public Etype l;
  public Etype r;
  
}
class Mult:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Data{}
class Var:Etype{}
class Const:Etype{}


class Program {
    static object Run() {
        var res = new Data[10];
        
              
        Var []env = new Var[3];
        Const c = new Const();
        c.setValue(6);
        

        Sub sb  = new Sub();
        sb.r = env[0];
        sb.l = env[1];
        
        Add ad2 = new Add();
        ad2.l = env[1];
        ad2.r = c;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c;
        
        //Add exp = ad1;        
        
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
        return new { root = ad1,env };
        
        
    }
}

HeapDbg/plsp

class Eobjects{}
class Etype:Eobjects {public Etype pointsto;} 

class Add:Etype{ public Eobjects l; public Eobjects r; }
class Sub:Etype{ public Eobjects l; public Eobjects r; }
class Mult:Etype{ public Eobjects l; public Eobjects r; }

class Var:Eobjects{}  
class Const:Eobjects{}


class Program {
  
    static Var []env = new Var[3];
    
    static object test(Etype exp, Var [] env)
    {
      
      return new { exp , env };
    }
    static object Run() {
              
        
        
        
        
        Var v1= new Var();
        Var v2= new Var();
        Var v3= new Var();
        
        env[0] = v1;
        env[1] = v2;
        Const c1 = new Const();
        Const c2 = new Const();
       
     

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
        Etype exp = new Etype();
        exp.pointsto = ad1;
        return new { exp , env };
        
     
       
    }
}

HeapDbg/plr

class Etype {} 

class Add:Etype{ public Etype l; public Etype r; }
class Sub:Etype{ public Etype l; public Etype r; }
class Mult:Etype{ public Etype l; public Etype r; }

class Var:Etype{}  
class Const:Etype{}


class Program {
    static object Run() {
              
        Var []env = new Var[3];
        Add local = new Add();
        
        
        Var v1= new Var();
        Var v2= new Var();
        Var v3= new Var();
        
        env[0] = v1;
        env[1] = v2;
        Const c1 = new Const();
        Const c2 = new Const();
       
     

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
                
        local.l = ad1;
        return new { local , env };
        
        
    }
}

HeapDbg/plhp

// Creates an array of un-aliased Data objects
class Etype { 
  
    public double value;
    public void setValue(double x)
    {
      value = x;
    }
}

class Add:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Sub:Etype{
  
  public Etype l;
  public Etype r;
  
}
class Mult:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Data{}
class Var:Etype{}
class Const:Etype{}


class Program {
    static object Run() {
              
        Var []env = new Var[3];
        Var v1 = null;
        Var v2 = null;
        
        env[0] = v1;
        env[0] = v2;
        
        Const c1 = new Const();
        Const c2 = new Const();
       
        

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        
        
        var exp = ad1;        
        var v;
        
        return new { root = exp , v = env };
        
        
    }
}

HeapDbg/pIM

// Creates an array of un-aliased Data objects
class Data { 
  
  public string getDeviceID()
  {
       return "121";
  }
}


class Program {
    static object Run() {
        string val;
        var res = new Data[10];
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
            
        val = res[0].getDeviceID();            
        return new {res };
    }
}

HeapDbg/pik

class Eobjects{}
class Etype:Eobjects {public Etype pointsto;} 

class Add:Etype{ public Eobjects l; public Eobjects r; }
class Sub:Etype{ public Eobjects l; public Eobjects r; }
class Mult:Etype{ public Eobjects l; public Eobjects r; }

class Var:Eobjects{}  
class Const:Eobjects{}


class Program {
    static object Run() {
              
        Var []env = new Var[3];
        
        
        
        Var v1= new Var();
        Var v2= new Var();
        Var v3= new Var();
        
        env[0] = v1;
        env[1] = v2;
        Const c1 = new Const();
        Const c2 = new Const();
       
     

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
        Etype exp = new Etype();
        exp.pointsto = ad1;
        return new { exp , env };
        
        
    }
}

HeapDbg/l4

// Creates an array of un-aliased Data objects
class Data {
  
  public  string getDeviceID()
  {
    return "12";
  }
 }
 
 class Test
 {
   
   public void print(string s)
   {
     
     string d = s;
   }
   
 }
 
class Program {
    static object Run() {
        var res = new Data();
        var ob = new Test();
        //for (int i = 0; i < res.Length; ++i)
        string s = res.getDeviceID();
           
        string s2 = s + "desh";   
        ob.print(s2);   
        return new { root = res };
    }
}

HeapDbg/L1r

// Creates an array of un-aliased Data objects
class Etype { 
  
    public double value;
    public void setValue(double x)
    {
      value = x;
    }
}

class Add:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Sub:Etype{
  
  public Etype l;
  public Etype r;
  
}
class Mult:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Data{}
class Var:Etype{}
class Const:Etype{}


class Program {
    static object Run() {
            
        var env = new var[3];
        
        
        env[0] = v1;
        env[0] = v2;
        
        Const c1 = new Const();
        Const c2 = new Const();
       
        

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        
        
        var exp = ad1;        
        
        
        return new { root = exp , variable = env };
        
        
    }
}

HeapDbg/KyW

// Creates an array of un-aliased Data objects
class Etype { 
  
    public double value;
    public double setValue(double x)
    {
      value = x;
    }
    public double getValue()
    {
      return value;
    }
  }

class Add:Etype{
  
  Etype l;
  Etype r;
  double getVal()
  {
    return (l.getValue()+r.getValue());    
  }
}

class Data{}

class Program {
    static object Run() {
        var res = new Data[10];
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
        return new { root = res };
    }
}

HeapDbg/kSZ

// Creates an array of un-aliased Data objects
class Etype { 
  
    public double value;
    public void setValue(double x)
    {
      value = x;
    }
    public double getValue()
    {
      return value;
    }
  }

class Add:Etype{
  
  Etype l;
  Etype r;
  double getVal()
  {
    return (l.getValue()+r.getValue());    
  }
}

class Data{}
class Var:Etype{
   
}

class Program {
    static object Run() {
        var res = new Data[10];
        
        Var env = new Var[3];
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
        return new { root = res };
        
        
    }
}

HeapDbg/kO

class Etype {object pointsto;} 

class Add:Etype{ public Etype l; public Etype r; }
class Sub:Etype{ public Etype l; public Etype r; }
class Mult:Etype{ public Etype l; public Etype r; }

class Var:Etype{}  
class Const:Etype{}


class Program {
    static object Run() {
              
        Var []env = new Var[3];
        
        Var v1= new Var();
        Var v2= new Var();
        Var v3= new Var();
        
        env[0] = v1;
        env[1] = v2;
        Const c1 = new Const();
        Const c2 = new Const();
       
     

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
                
        Etype exp = new Etype();
        exp.pointsto = ad1;
        
        return new { exp , env };
        
        
    }
}

HeapDbg/KG4

class Etype {} 

class Add:Etype{ public Etype l; public Etype r; }
class Sub:Etype{ public Etype l; public Etype r; }
class Mult:Etype{ public Etype l; public Etype r; }

class Var:Etype{}  
class Const:Etype{}


class Program {
    static object Run() {
              
        Var []env = new Var[3];
        
        Var v1= new Var();
        Var v2= new Var();
        Var v3= new Var();
        
        env[0] = v1;
        env[1] = v2;
        Const c1 = new Const();
        Const c2 = new Const();
       
     

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
                
        var  exp = ad1;
        
        
        return new { this , env };
        
        
    }
}

HeapDbg/KcP

// Creates an array of un-aliased Data objects
class Data { 
  
  public string getDeviceID()
  {
       return "123456";
  }
}


class Program {
    static object Run() {
        string val;
        var res = new Data[10];
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
            
        val = res[0].getDeviceID();            
        return new { root = res };
    }
}

HeapDbg/gf

class Eobjects{}
class Etype:Eobjects {public Etype pointsto;} 

class Add:Etype{ public Eobjects l; public Eobjects r; }
class Sub:Etype{ public Eobjects l; public Eobjects r; }
class Mult:Etype{ public Eobjects l; public Eobjects r; }

class Var:Eobjects{}  
class Const:Eobjects{}


class Program {
  
    static Var []env = new Var[3];
    
    static object test(Etype exp, Var [] env)
    {
      
      return new { exp , env };
    }
    static object Run() {
              
        Var []env = new Var[3];
        
        
        
        Var v1= new Var();
        Var v2= new Var();
        Var v3= new Var();
        
        env[0] = v1;
        env[1] = v2;
        Const c1 = new Const();
        Const c2 = new Const();
       
     

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
        Etype exp = new Etype();
        exp.pointsto = ad1;
        return new { exp , env };
        
     
       
    }
}

HeapDbg/fpl

// Creates an array of un-aliased Data objects
class Etype { 
  
    public double value;
    public void setValue(double x)
    {
      value = x;
    }
}

class Add:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Sub:Etype{
  
  public Etype l;
  public Etype r;
  
}
class Mult:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Data{}
class Var:Etype{}
class Const:Etype{}


class Program {
    static object Run() {
            
        var env = new var[3];
        var v1 = null;
        var v2 = null;
        
        env[0] = v1;
        env[0] = v2;
        
        Const c1 = new Const();
        Const c2 = new Const();
       
        

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        
        
        var exp = ad1;        
        
        
        return new { root = exp , variable = env };
        
        
    }
}

HeapDbg/fI

// Creates an array of un-aliased Data objects
class Data { 
  
  public string getDeviceID()
  {
       return "121";
  }
}


class Program {
    static object Run() {
        string val;
        var res = new Data[10];
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
            
        val = res[0].getDeviceID();            
        return new { root = res };
    }
}

HeapDbg/fD

// Creates an array of un-aliased Data objects

class Eobjects{
  
 public Etype pointer;
  
}

class Etype:Eobjects { 
  
    public double value;
    
    public void setValue(double x)
    {
      value = x;
    }
}

class Add:Etype{
  
  public Etype l;
  public Etype r;
  
  
}

class Sub:Etype{
  
  public Etype l;
  public Etype r;
  
}
class Mult:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Data{}
class Var:Etype{
  
  
}
class Const:Etype{}


class Program {
    static object Run() {
              
        Var []env = new Var[3];
        
        Var v1= new Var();
        Var v2= new Var();
        Var v3= new Var();
        
        env[0] = v1;
        env[1] = v2;
        Const c1 = new Const();
        Const c2 = new Const();
       
        

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
                
        Eobjects  exp = new Eobjects();
        exp.pointer  = ad1; 
        
        return new { root = exp , v = env };
        
        
    }
}

HeapDbg/dR

class Eobjects{}
class Etype:Eobjects {public Etype pointsto;} 

class Add:Etype{ public Etype l; public Etype r; }
class Sub:Etype{ public Etype l; public Etype r; }
class Mult:Etype{ public Etype l; public Etype r; }

class Var:Eobjects{}  
class Const:Eobjects{}


class Program {
    static object Run() {
              
        Var []env = new Var[3];
        
        
        
        Var v1= new Var();
        Var v2= new Var();
        Var v3= new Var();
        
        env[0] = v1;
        env[1] = v2;
        Const c1 = new Const();
        Const c2 = new Const();
       
     

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
        Add exp = new Add();
        exp.l = ad1;
        return new { exp , env };
        
        
    }
}

HeapDbg/Dp

// Creates an array of un-aliased Data objects
class Data {
  
  public  string getDeviceID()
  {
    return "123456";
  }
 }
class Program {
    static object Run() {
        var res = new Data();
        
        //for (int i = 0; i < res.Length; ++i)
            string s = res.getDeviceID();
        return new { root = s };
    }
}

HeapDbg/Dly

// Creates an array of un-aliased Data objects
class Etype { 
  
    public double value;
    public void setValue(double x)
    {
      value = x;
    }
}

class Add:Etype{
  
  Etype l;
  Etype r;
  
}

class Sub:Etype{
  
  Etype l;
  Etype r;
  
}
class Mult:Etype{
  
  Etype l;
  Etype r;
  
}

class Data{}
class Var:Etype{}
class Const:Etype{}


class Program {
    static object Run() {
        var res = new Data[10];
        
        var exp;
        
        Var []env = new Var[3];
        Const c1 = new Const();
        Const c2 = new Const();
        c1.setValue(5);
        c1.setValue(6);
        

        Sub sb  = new Sub();
        sb.l = env[0];
        sb.l = env[1];
        
        Add ad2 = new Add();
        ad2.l = env[1];
        ad2.r = c2;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c1;
        
        exp = ad1;        
        
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
        return new { root = exp };
        
        
    }
}

HeapDbg/dKH

// Creates an array of un-aliased Data objects
class Data { 
  
  public string getDeviceID()
  {
       return "12";
  }
}


class Program {
    static object Run() {
        string val;
        var res = new Data[10];
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
            
        val = res[0].getDeviceID();            
        return new { root = res };
    }
}

HeapDbg/dHM

// Creates an array of un-aliased Data objects
class Etype { 
  
    public double value;
    public void setValue(double x)
    {
      value = x;
    }
}

class Add:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Sub:Etype{
  
  public Etype l;
  public Etype r;
  
}
class Mult:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Data{}
class Var:Etype{}
class Const:Etype{}


class Program {
    static object Run() {
        var res = new Data[10];
        
        var exp = null;
        
        Var []env = new Var[3];
        Const c1 = new Const();
        Const c2 = new Const();
        c1.setValue(5);
        c1.setValue(6);
        

        Sub sb  = new Sub();
        sb.l = env[0];
        sb.l = env[1];
        
        Add ad2 = new Add();
        ad2.l = env[1];
        ad2.r = c2;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c1;
        
        exp = ad1;        
        
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
        return new { root = exp };
        
        
    }
}

HeapDbg/df

// Creates an array of un-aliased Data objects
class Etype { 
  
    public double value;
    public void setValue(double x)
    {
      value = x;
    }
}

class Add:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Sub:Etype{
  
  public Etype l;
  public Etype r;
  
}
class Mult:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Data{}
class Var:Etype{}
class Const:Etype{}


class Program {
    static object Run() {
            
        var []env = new var[3];
        var v1 = null;
        var v2 = null;
        
        env[0] = v1;
        env[0] = v2;
        
        Const c1 = new Const();
        Const c2 = new Const();
       
        

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        
        
        var exp = ad1;        
        
        
        return new { root = exp , variable = env };
        
        
    }
}

HeapDbg/bnL

// Creates an array of un-aliased Data objects
class Etype { 
  
    public double value;
    public void setValue(double x)
    {
      value = x;
    }
}

class Add:Etype{
  
  public Etype l;
  public Etype r;
  
  
}

class Sub:Etype{
  
  public Etype l;
  public Etype r;
  
}
class Mult:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Data{}
class Var:Etype{
  
  public Etype arrayIndex;
}
class Const:Etype{}


class Program {
    static object Run() {
              
        Var []env = new Var[3];
        Var v1 = null;
        Var v2 = null;
        
        env[0].arrayIndex = v1;
        env[0].arrayIndex = v2;
        
        Const c1 = new Const();
        Const c2 = new Const();
       
        

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
        var exp = ad1;        
        
        
        return new { root = exp , v = env };
        
        
    }
}

HeapDbg/blw

// Creates a Tree of Data objects
using System;
namespace HelloWorld
{
    class Program
    {
        static void Main() 
        {
            
        }
    }
}

HeapDbg/af

// Creates an array of un-aliased Data objects
class Etype { 
  
    public double value;
    
    public void setValue(double x)
    {
      value = x;
    }
}

class Add:Etype{
  
  public Etype l;
  public Etype r;
  
  
}

class Sub:Etype{
  
  public Etype l;
  public Etype r;
  
}
class Mult:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Data{}
class Var:Etype{
  
  
}
class Const:Etype{}


class Program {
    static object Run() {
              
        Var []env = new Var[3];
        
        Var v1= new Var();
        Var v2= new Var();
        Var v3= new Var();
        
        env[0] = v1;
        env[1] = v2;
        Const c1 = new Const();
        Const c2 = new Const();
       
        

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
                
        object  exp = new object();
        exp = ad1; 
        
        return new { root = exp , v = env };
        
        
    }
}

HeapDbg/AA

// Creates an array of un-aliased Data objects

class Eobjects{
  
 Etype pointer;
  
}

class Etype:Eobjects { 
  
    public double value;
    
    public void setValue(double x)
    {
      value = x;
    }
}

class Add:Etype{
  
  public Etype l;
  public Etype r;
  
  
}

class Sub:Etype{
  
  public Etype l;
  public Etype r;
  
}
class Mult:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Data{}
class Var:Eobjects{
  
  
}
class Const:Eobjects{}


class Program {
    static object Run() {
              
        Var []env = new Var[3];
        
        Var v1= new Var();
        Var v2= new Var();
        Var v3= new Var();
        
        env[0] = v1;
        env[1] = v2;
        Const c1 = new Const();
        Const c2 = new Const();
       
        

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
                
        Eobjects  exp = new Eobjects();
        exp.pointer  = (Etype *)ad1; 
        
        return new { root = exp , v = env };
        
        
    }
}

HeapDbg/9Y

class Etype {} 

class Add:Etype{ public Etype l; public Etype r; }
class Sub:Etype{ public Etype l; public Etype r; }
class Mult:Etype{ public Etype l; public Etype r; }

class Var:Etype{}  
class Const:Etype{}


class Program {
  
    static object test(){
      
      
      Var []env = new Var[3];
        
        
        
        Var v1= new Var();
        Var v2= new Var();
        Var v3= new Var();
        
        env[0] = v1;
        env[1] = v2;
        Const c1 = new Const();
        Const c2 = new Const();
       
     

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
        Etype exp = new Etype();         
        exp = ad1;
        return new { exp , env }; 
      
    }
    
    static onject Run() {
              
     object ob = test();
     return ob;  
    }
}

HeapDbg/4s

// Create an array of aliased Data objects
// Alising is shown as XXX color on [?] edge.
class Data { public int Value; }
class Program {
    static object Run() {
        var res = new Data[10];
        for (int i = 0; i < res.Length; ++i) {
            if (i % 2 == 0)
                res[i] = new Data();
            else
                res[i] = res[i - 1];
        }
        return new { root = res };
    }
}

HeapDbg/2Y

// Creates an array of un-aliased Data objects
class Etype { 
  
    public double value;
    public Etype pointer;
    public void setValue(double x)
    {
      value = x;
    }
}

class Add:Etype{
  
  public Etype l;
  public Etype r;
  
  
}

class Sub:Etype{
  
  public Etype l;
  public Etype r;
  
}
class Mult:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Data{}
class Var:Etype{
  
  
}
class Const:Etype{}


class Program {
    static object Run() {
              
        Var []env = new Var[3];
        
        Var v1= new Var();
        Var v2= new Var();
        Var v3= new Var();
        
        env[0] = v1;
        env[1] = v2;
        Const c1 = new Const();
        Const c2 = new Const();
       
        

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
                
        Etype exp = new Etype();
        exp.pointer = ad1;
        
        return new { root = exp , v = env };
        
        
    }
}

HeapDbg/23D

// Creates an array of un-aliased Data objects
class Etype { 
  
    public double value;
    public Etype pointer;
    public void setValue(double x)
    {
      value = x;
    }
}

class Add:Etype{
  
  public Etype l;
  public Etype r;
  
  
}

class Sub:Etype{
  
  public Etype l;
  public Etype r;
  
}
class Mult:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Data{}
class Var:Etype{
  
  
}
class Const:Etype{}


class Program {
    static object Run() {
              
        Var []env = new Var[3];
        
        Var v1= new Var();
        Var v2= new Var();
        Var v3= new Var();
        
        env[0] = v1;
        env[1] = v2;
        Const c1 = new Const();
        Const c2 = new Const();
       
        

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
                
        Etype exp = new Add();
        exp.l = ad1; 
        
        return new { root = exp , v = env };
        
        
    }
}

HeapDbg/1G

// Creates an array of un-aliased Data objects
class Etype { 
  
    public double value;
    public Etype pointer;
    public void setValue(double x)
    {
      value = x;
    }
}

class Add:Etype{
  
  public Etype l;
  public Etype r;
  
  
}

class Sub:Etype{
  
  public Etype l;
  public Etype r;
  
}
class Mult:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Data{}
class Var:Etype{
  
  
}
class Const:Etype{}


class Program {
    static object Run() {
              
        Var []env = new Var[3];
        
        Var v1= new Var();
        Var v2= new Var();
        Var v3= new Var();
        
        env[0] = v1;
        env[1] = v2;
        Const c1 = new Const();
        Const c2 = new Const();
       
        

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
                
        Add exp = new Etype();
        exp.l = ad1; 
        
        return new { root = exp , v = env };
        
        
    }
}

HeapDbg/1a

class Eobjects{}
class Etype:Eobjects {public Etype pointsto;} 

class Add:Etype{ public Eobjects l; public Eobjects r; }
class Sub:Etype{ public Eobjects l; public Eobjects r; }
class Mult:Etype{ public Eobjects l; public Eobjects r; }

class Var:Eobjects{}  
class Const:Eobjects{}


class Program {
    
    static object test(Etype exp, Var env[])
    {
      
      return new { exp , env };
    }
    static void Run() {
              
        Var []env = new Var[3];
        
        
        
        Var v1= new Var();
        Var v2= new Var();
        Var v3= new Var();
        
        env[0] = v1;
        env[1] = v2;
        Const c1 = new Const();
        Const c2 = new Const();
       
     

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
        Etype exp = new Etype();
        exp = ad1;
        //return new { exp , env };
        
        object ob = test(exp,env);
        return ob;
    }
}

HeapDbg/0l

class Eobjects{}
class Etype:Eobjects {public Etype pointsto;} 

class Add:Etype{ public Eobjects l; public Eobjects r; }
class Sub:Etype{ public Eobjects l; public Eobjects r; }
class Mult:Etype{ public Eobjects l; public Eobjects r; }

class Var:Eobjects{}  
class Const:Eobjects{}


class Program {
    
    static object test(Etype exp, new Var[3])
    {
      
      return new { exp , env };
    }
    static void Run() {
              
        Var []env = new Var[3];
        
        
        
        Var v1= new Var();
        Var v2= new Var();
        Var v3= new Var();
        
        env[0] = v1;
        env[1] = v2;
        Const c1 = new Const();
        Const c2 = new Const();
       
     

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
        Etype exp = new Etype();
        exp = ad1;
        //return new { exp , env };
        
        object ob = test(exp,env);
        return ob;
    }
}

HeapDbg/0G

// Creates a heap and returns each root as a field of the return object
public class Hello { //public World World; 

            Hello(int x)
            {
              
              
            }  
}
public class World { 
  
  public int getId()
              {
                return 100;
              }
  
}

class Program {
    static object Run() {
      
        int id;
        
        var res = new Hello { new World().getId() };
        
        return new { root = res };
    }
}

HeapDbg/0EH

// Creates a heap and returns each root as a field of the return object
class Hello { //public World World; 

            Hello(int x)
            {
              
              
            }  
}
class World { 
  
  public int getId()
              {
                return 100;
              }
  
}

class Program {
    static object Run() {
      
        int id;
        
        var res = new Hello { new World().getId() };
        
        return new { root = res };
    }
}

HeapDbg/wS

// Creates an array of un-aliased Data objects
class Data { }
class Program {
    static object Run() {
        var res = new Data[10];        var res1 = new Data[10];
        for (int i = 0; i < res.Length; ++i)            for(int j=0; j< res.1Length; j++)                res1[j] = new Data();
            res[i] = new Data();
        return new { root = res };
    }
}

HeapDbg/Wp

// Creates an array of un-aliased Data objects, some entries are null.
class Data { }
class Program {
    static object Run() {
        var res = new Data[100];
        for (int i = 0; i < 10000; ++i) {
            //if (i % 2 != 0 && i % 3 != 0)
                res[i] = new Data();
        }
        return new { root = res };
    }
}

HeapDbg/QSM

Could not find sample or program chris

HeapDbg/QG

// Creates an array of un-aliased Data objects
class Data { }
class Program {
    static object Run() {
        var res = new Data[10];
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
        return res ;
    }
}

HeapDbg/Qp0

// Create a LinkedList of Data objects
// Self edge on, Next, and label, List
class Data { }
class ListNode { public ListNode Next,Prev; public Data Data; }
class Program {
    static object Run() {
        ListNode res = null;
        for (int i = 0; i < 10; ++i)
            res = new ListNode { Next = res, Data = new Data() };
        return new { root = res };
    }
}

HeapDbg/qGP

If I were a Teneage Mutant Ninja Turtle, now I'd say "Kowabunga, dude!"

HeapDbg/vo

// Creates an array of un-aliased Data objects, some entries are null.
class Data { }
class Program {
    static object Run() {
        var res = new Data[20];
        for (int i = 0; i < 20; ++i) {
            if (i % 2 != 0 && i % 3 != 0)
                res[i] = new Data();
        }
        return new { root = res };
    }
}

HeapDbg/fJW

// Creates an array of un-aliased Data objects
class Data { 
int i = 0
}
class Program {
    static object Run() {
        var res = new Data[10];
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
        return new { root = res };
    }
}

HeapDbg/fh

Created the greatest artilecs, you have.

HeapDbg/slU

// Creates an array of un-aliased Data objects
class Data { int i; }
class Program {
    static object Run() {
        var res = { a = new Data[10], b = new Data[5] };
        for (int i = 0; i < res.Length; ++i)
            res.a[i] = new Data();
        return new { root = res };
    }
}

HeapDbg/dUi

// Creates an array of un-aliased Data objects
class Data { }
class Program {
    static object Run() {
        var res = new Data[10];
        res[0] = new Data();
        for (int i = 1; i < res.Length; ++i)
            res[i] = res[i-1];
        return new { root = res };
    }
}

HeapDbg/dU

// Creates an array of un-aliased Data objects
class Data {
  
  public static string getDeviceID()
  {
    return "123456";
  }
 }
class Program {
    static object Run() {
        var res = new Data[10];
        
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
        return new { root = res };
    }
}

HeapDbg/Kg

using System;

public class Result { public STreeNode tree; public Color scolor;}

	public class Program
	{
		public static object Run()
		{
			Color special = new Color { red = 0, blue = 255, green = 0 };
			STreeNode rtn = STreeNode.MakeTree(3, special);

			return new Result { tree = rtn, scolor = special };
		}
	}

	public class STreeNode
	{
		public STreeNode left; public STreeNode right; public Sphere[] data;

		public static STreeNode MakeTree(int k, Color c)
		{
			if(k == 0)
				return null;
			else
			{
Point cp = new Point { xpos = k, ypos = k, zpos = k };

				Sphere[] sph = new Sphere[5];
				for(int i = 0; i < 5; ++i)
				{
										sph[i] = new Sphere { center = cp, color = c, radius = 1F };
				}
			
				return new STreeNode { left = MakeTree(k - 1, c), right = MakeTree(k - 1, c), data = sph };
			}
		}
	}

	public class Sphere { public Point center; public Color color; public float radius; }
	public class Color { public int red; public int blue; public int green; }
	public class Point { public float xpos; public float ypos; public float zpos; }

HeapDbg/dsl

// Creates an array of un-aliased Data objects
class Etype { 
  
    public double value;
    public void setValue(double x)
    {
      value = x;
    }
    public double getValue()
    {
      return value;
    }
  }

class Add:Etype{
  
  Etype l;
  Etype r;
  double getVal()
  {
    return (l.getValue()+r.getValue());    
  }
}

class Data{}
class Var:Etype{
   
}

class Program {
    static object Run() {
        var res = new Data[10];
        
        Var env[] = new Var[3];
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
        return new { root = res };
        
        
    }
}

HeapDbg/Qa

2vFC4J  <a href="http://pmeykkcxazqv.com/">pmeykkcxazqv</a>, [url=http://szwlppyamgny.com/]szwlppyamgny[/url], [link=http://fppwspqngjrl.com/]fppwspqngjrl[/link], http://anwbtyilpdus.com/

HeapDbg/7p

// Creates an array of un-aliased Data objects
class Etype { 
  
    public double value;
    public void setValue(double x)
    {
      value = x;
    }
}

class Add:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Sub:Etype{
  
  public Etype l;
  public Etype r;
  
}
class Mult:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Data{}
class Var:Etype{}
class Const:Etype{}


class Program {
    static object Run() {
        var res = new Data[10];
        
              
        Var []env = new Var[3];
        Const c1 = new Const();
        Const c2 = new Const();
        c1.setValue(5);
        c1.setValue(6);
        

        Sub sb  = new Sub();
        sb.l = env[0];
        sb.l = env[1];
        
        Add ad2 = new Add();
        ad2.l = env[1];
        ad2.r = c2;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c1;
        
        var exp = ad1;        
        
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
        return new { root = exp };
        
        
    }
}

HeapDbg/UhS

class Etype {} 

class Add:Etype{ public Etype l; public Etype r; }
class Sub:Etype{ public Etype l; public Etype r; }
class Mult:Etype{ public Etype l; public Etype r; }

class Var:Etype{}  
class Const:Etype{}


class Program {
    static object Run() {
              
        Var []env = new Var[3];
        
        Var v1= new Var();
        Var v2= new Var();
        Var v3= new Var();
        
        env[0] = v1;
        env[1] = v2;
        Const c1 = new Const();
        Const c2 = new Const();
       
     

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
                
        Add  exp = new Add();
        exp.l = ad1; 
        
        return new { root = exp , env };
        
        
    }
}

HeapDbg/Uf

// Creates an array of un-aliased Data objects
class Etype { 
  
    public double value;
    
    public void setValue(double x)
    {
      value = x;
    }
}

class Add:Etype{
  
  public Etype l;
  public Etype r;
  
  
}

class Sub:Etype{
  
  public Etype l;
  public Etype r;
  
}
class Mult:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Data{}
class Var:Etype{
  
  
}
class Const:Etype{}


class Program {
    static object Run() {
              
        Var []env = new Var[3];
        
        Var v1= new Var();
        Var v2= new Var();
        Var v3= new Var();
        
        env[0] = v1;
        env[1] = v2;
        Const c1 = new Const();
        Const c2 = new Const();
       
        

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
                
        Add exp = new Add();
        exp.l = ad1; 
        
        return new { root = exp , v = env };
        
        
    }
}

HeapDbg/tzR

// Creates an array of un-aliased Data objects
class Data { }
class Program {
    static object Run() {
        var res = new Data[10];
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
        return new { root = res };
    }

}
class items { }

HeapDbg/tZ

// Creates an array of un-aliased Data objects
public class Hello{
   public static void main(String[]args){
      System.out.println("Hello");
   }
}

HeapDbg/ph

Touchdown! That's a really cool way of ptutnig it!

HeapDbg/PG

// Creates an array of un-aliased Data objects
class Etype { 
  
    public double value;
    public void setValue(double x)
    {
      value = x;
    }
}

class Add:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Sub:Etype{
  
  public Etype l;
  public Etype r;
  
}
class Mult:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Data{}
class Var:Etype{}
class Const:Etype{}


class Program {
    static object Run() {
        var res = new Data[10];
        
              
        Var []env = new Var[3];
        Const c1 = new Const();
        Const c2 = new Const();
        c1.setValue(5);
        c1.setValue(6);
        

        Sub sb  = new Sub();
        sb.l = env[0];
        sb.l = env[1];
        
        Add ad2 = new Add();
        ad2.l = env[1];
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c1;
        
        Add exp = ad1;        
        
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
        return new { root = exp,env };
        
        
    }
}

HeapDbg/pF

// Creates an array of un-aliased Data objects
class Data { }
class Program {
    static object Run() {
        var res = new Data[10];
        for (int i = 0; i < res.Length; ++i)
  ();
        return new { root = res };
    }
}

HeapDbg/9U

// Creates an array of un-aliased Data objects
class Data { }
class Program {
    static object Run() {
        var res = new Data[10];
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();ш
        return new { root = res };
    }
}

HeapDbg/Pbk

// Create an array of un-aliased Shperes.
// Each a composite object of an unaliased Point object and Color object
class Color { public int red; public int blue; public int green; }
class Point { public float xpos; public float ypos; public float zpos; }
class Sphere { 
    public Point center; 
    public Color color; 
    public float radius; 
}
class Program {
    static object Run() {
        var spheres = new Sphere[10];
        for (int i = 0; i < spheres.Length; ++i) {
            var ctr = new Point { xpos = i, ypos = i + 1, zpos = i - 1 };
            var rgb = new Color { red = i, blue = i, green = i };
            spheres[i] = new Sphere { center = ctr, color = rgb, radius = 3.0F };
        }
        return new { spheres = new string[]{"a", "b", "c"} };
    }
}

HeapDbg/P2

class Etype {} 

class Add:Etype{ public Etype l; public Etype r; }
class Sub:Etype{ public Etype l; public Etype r; }
class Mult:Etype{ public Etype l; public Etype r; }

class Var:Etype{}  
class Const:Etype{}


class Program {
    static object Run() {
              
        Var []env = new Var[3];
        
        Var v1= new Var();
        Var v2= new Var();
        Var v3= new Var();
        
        env[0] = v1;
        env[1] = v2;
        Const c1 = new Const();
        Const c2 = new Const();
       
     

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
                
        Var  exp = new Var();
        exp.l = ad1; 
        
        return new { root = exp , v = env };
        
        
    }
}

HeapDbg/JC6

// Creates an array of un-aliased Data objects
class Data {int i; }
class Program {
    static object Run() {
        var res = new Data[11];
        for (int i = 0; i < res.Length; ++i)
            {res[i] = new Data();res[i].i = i;}        res[10].i = 7829;
        return new { root = res };
    }
}

HeapDbg/jb

// Creates an array of un-aliased Data objects
class Data { }
class Program {
    static object Run() {
        var res = new Data[10];
        for (int i = 0; i < res.Length; ++i)
            res[i] = newt Data();
        return new { root = res };
    }
}

HeapDbg/Dn

// Creates an array of un-aliased Data objects, some entries are null.
class Data { }
class Program {
    static object Run() {
        var res = new Data[100];
        for (int i = 0; i < 10; ++i) {
            //if (i % 2 != 0 && i % 3 != 0)
                res[i] = new Data();
        }
        return new { root = res };
    }
}

HeapDbg/BB

// Creates an array of un-aliased Data objects
class Etype { 
  
    public double value;
    public Etype pointer;
    public void setValue(double x)
    {
      value = x;
    }
}

class Add:Etype{
  
  public Etype l;
  public Etype r;
  
  
}

class Sub:Etype{
  
  public Etype l;
  public Etype r;
  
}
class Mult:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Data{}
class Var:Etype{
  
  
}
class Const:Etype{}


class Program {
    static object Run() {
              
        Var []env = new Var[3];
        
        Var v1= new Var();
        Var v2= new Var();
        Var v3= new Var();
        
        env[0] = v1;
        env[1] = v2;
        Const c1 = new Const();
        Const c2 = new Const();
       
        

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
                
        Etype exp = new Etype();
        exp.pointer = ad1;
        
        return new { root = ad1 , v = env };
        
        
    }
}

HeapDbg/9v

// Creates an array of un-aliased Data objects
class Etype { 
  
    public double value;
    public void setValue(double x)
    {
      value = x;
    }
}

class Add:Etype{
  
  public Etype l;
  public Etype r;
  public Etype arrayIndex;
  
}

class Sub:Etype{
  
  public Etype l;
  public Etype r;
  
}
class Mult:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Data{}
class Var:Etype{}
class Const:Etype{}


class Program {
    static object Run() {
              
        Var []env = new Var[3];
        Var v1 = null;
        Var v2 = null;
        
        env[0].arrayIndex = v1;
        env[0].arrayIndex = v2;
        
        Const c1 = new Const();
        Const c2 = new Const();
       
        

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
        var exp = ad1;        
        
        
        return new { root = exp , v = env };
        
        
    }
}

HeapDbg/4

using System;

	public class Program
	{
		public static object Run()
		{
			Sphere[] spheres = new Sphere[10];

			for(int i = 0; i < 10; ++i)
			{
				Point ctr = new Point { xpos = i, ypos = i + 1, zpos = i - 1 };
				Color rgb = new Color { xpos = i, ypos = i, zpos = i };
				spheres[i] = new Sphere { center = ctr, color = rgb, radius = 3.0 };
			}

			return new Result { array = resa, special = dspecial };
		}
	}

	public class Sphere { public Point center; public Color color; public float radius; }
	public class Color { public int red; public int blue; public int green; }
	public class Point { public float xpos; public float ypos; public float zpos; }

HeapDbg/2O2

Umm, are you really just gviing this info out for nothing?

HeapDbg/VK

To think, I was confused a mitnue ago.

HeapDbg/0V7

// Create a LinkedList of Data objects
// Self edge on, Next, and label, List
class Data { }
class ListNode { public ListNode Next; public Data Data; }
class Program {
    static object Run() {
        ListNode res = null;
        for (int i = 0; i < 10; ++i) {
            res = new ListNode { Next = res, Data = new Data() };
if (i == 5)
            res = new ListNode {};
        }
        return new { root = res };
    }
}

HeapDbg/Uy

// Creates an array of un-aliased Data objects, some entries are null.
class Data { 
  public Data other;
}
class Program {
    static object Run() {
        var res = new Data[10];
        for (int i = 0; i < 10; ++i) {
            if (i % 2 != 0 && i % 3 != 0) {
                res[i] = new Data();
                res[i].other = new Data();
            }
        }
        return new { root = res };
    }
}

HeapDbg/uTP

// Creates an array of un-aliased Data objects
class Data { 
  
  public string getDeviceID()
  {
       return "121";
  }
}


class Program {
    static object Run() {
        string val;
        var res = new Data[10];
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
            
        val = res[0].getDeviceID();            
        return new {root = res };
    }
}

HeapDbg/ut

// Creates an array of un-aliased Data objects, some entries are null.
class Data { }
public class Program
    {
        Program f;
        public static Object run(Program param)
        {
            Program local1 = bar();
            Program local2 = bar();
            local1.f = param;
            local2.f = new Program();
            local2.f.f = new Program();
            return  local1;
        }

        public Program bar()
        {
            Program r = new Program();
            return r;
        }
    }

HeapDbg/B

using System;

public class Result { public STreeNode tree; public Color scolor;}

	public class Program
	{
		public static object Run()
		{
			Color special = new Color { red = 0, blue = 255, green = 0 };
			STreeNode rtn = STreeNode.MakeTree(3, special);

			return new Result { tree = rtn, scolor = special };
		}
	}

	public class STreeNode
	{
		public STreeNode left; public STreeNode right; public Sphere[] data;

		public static STreeNode MakeTree(int k, Color c)
		{
			if(k == 0)
				return null;
			else
			{

                          Point cp = new Point { xpos = k, ypos = k, zpos = k };
				Sphere[] sph = new Sphere[5];
				for(int i = 0; i < 5; ++i)
				{
				 sph[i] = new Sphere { center = cp, color = c, radius = 1F };
				}
			
				return new STreeNode { left = MakeTree(k - 1, c), right = MakeTree(k - 1, c), data = sph };
			}
		}
	}

	public class Sphere { public Point center; public Color color; public float radius; }
	public class Color { public int red; public int blue; public int green; }
	public class Point { public float xpos; public float ypos; public float zpos; }

HeapDbg/UPa

class Etype {} 

class Add:Etype{ public Etype l; public Etype r; }
class Sub:Etype{ public Etype l; public Etype r; }
class Mult:Etype{ public Etype l; public Etype r; }

class Var:Etype{}  
class Const:Etype{}


class Program {
  
    static object test(Etype exp){
      
        Var []env = new Var[3];
        Var v1= new Var();
        Var v2= new Var();
        Var v3= new Var();
        
        env[0] = v1;
        env[1] = v2;
        Const c1 = new Const();
        Const c2 = new Const();
       
     

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
                 
        exp = ad1;
        return new { exp , env }; 
      
    }
    
    static object Run() {
              
     Etype exp = new Etype();              
     object ob = test(exp);
     return ob;  
    }
}

HeapDbg/um2

// Create a LinkedList of Data objects
// Self edge on, Next, and label, List
class Data { }
class ListNode { public ListNode Next; public Data Data; }
class Program {
    static object Run() {
        ListNode res = null;
        for (int i = 0; i < 10; ++i) {
            res = new ListNode { Next = res, Data = new Data() };
if (i == 5)
            res = null;
        }
        return new { root = res };
    }
}

HeapDbg/PkU

// Create a LinkedList of Data objects
// Self edge on, Next, and label, List
class Data { }
class ListNode { public ListNode Next; public Data Data; }
class Program {
    static object Run() {
        ListNode res = null;
        ListNode res_init = null;
        for (int i = 0; i < 10; ++i)
{            res = new ListNode { Next = res, Data = new Data() };
if (i==0) res_init=res;}
        return new { root = res_init };
    }
}

HeapDbg/jX4

// Creates an array of un-aliased Data objects
class Data { }
class Program {
    static object Run() {
        var res = new Data[10];
        foytr (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
        return new { root = res };
    }
}

HeapDbg/jRf

class Etype {} 

class Add:Etype{ public Etype l; public Etype r; }
class Sub:Etype{ public Etype l; public Etype r; }
class Mult:Etype{ public Etype l; public Etype r; }

class Var:Etype{}  
class Const:Etype{}


class Program {
    static void Run() {
              
        Var []env = new Var[3];
        
        
        
        Var v1= new Var();
        Var v2= new Var();
        Var v3= new Var();
        
        env[0] = v1;
        env[1] = v2;
        Const c1 = new Const();
        Const c2 = new Const();
       
     

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
        Add exp = new Add();
        exp.l = ad1;
        //return new { exp , env };
        
        
    }
}

HeapDbg/dEp

class Data { public int val;}
class SpecialData: Data {}
class Program {
    static object Run() {
        var resa = new Data[10];
        var dspecial = new SpecialData();
        for (int i = 0; i < resa.Length; ++i) {
            if (i == 5)
                resa[i] = dspecial;
            else
                resa[i] = new Data();
        }
        return new { array = resa /*, special = dspecial */ };
    }
}

HeapDbg/F8s

class Eobjects{}
class Etype:Eobjects {public Etype pointsto;} 

class Add:Etype{ public Eobjects l; public Eobjects r; }
class Sub:Etype{ public Eobjects l; public Eobjects r; }
class Mult:Etype{ public Eobjects l; public Eobjects r; }

class Var:Eobjects{}  
class Const:Eobjects{}


class Program {
    
    static object test(Etype exp, Var [] env)
    {
      
      return new { exp , env };
    }
    static void Run() {
              
        Var []env = new Var[3];
        
        
        
        Var v1= new Var();
        Var v2= new Var();
        Var v3= new Var();
        
        env[0] = v1;
        env[1] = v2;
        Const c1 = new Const();
        Const c2 = new Const();
       
     

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
        Etype exp = new Etype();
        exp = ad1;
        //return new { exp , env };
        
        object ob = test(exp,env);
        return ob;
    }
}

HeapDbg/ELd

// Creates an array of un-aliased Data objects
class Data 
{ 
  int foo;
  long bar;
}
class Program {
    static object Run() {
        var res = new System.Collections.Generic.List<Data>(80000);
        for (int i = 0; i < res.Count; ++i)
            res[i] = new Data();
        return new { root = res };
    }
}

HeapDbg/A7

// Creates an array of un-aliased Data objects

class Program {
    static object Run() {
        return new {hello= "hello"};
    }
}

HeapDbg/86

It's about time soomnee wrote about this.

HeapDbg/8

using System;

public class Result { public STreeNode tree; public Color scolor;}

	public class Program
	{
		public static object Run()
		{
			Color special = new Color { red = 0, blue = 255, green = 0 };
			STreeNode rtn = STreeNode.MakeTree(3, special);

			return new Result { tree = rtn, scolor = special };
		}
	}

	public class STreeNode
	{
		public STreeNode left; public STreeNode right; public Sphere[] data;

		public static STreeNode MakeTree(int k, Color c)
		{
			if(k == 0)
				return null;
			else
			{

                          Sphere[] sph = new Sphere[5];
				for(int i = 0; i < 5; ++i)
				{
					Point cp = new Point { xpos = k, ypos = k, zpos = k };
					sph[i] = new Sphere { center = null, color = c, radius = 1F };
				}
				return new STreeNode { left = MakeTree(k - 1, c), right = MakeTree(k - 1, c), data = sph };
			}
		}
	}

	public class Sphere { public Point center; public Color color; public float radius; }
	public class Color { public int red; public int blue; public int green; }
	public class Point { public float xpos; public float ypos; public float zpos; }

HeapDbg/7xG

// Creates an array of un-aliased Data objects
class Etype { 
  
    public double value;
    public void setValue(double x)
    {
      value = x;
    }
}

class Add:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Sub:Etype{
  
  public Etype l;
  public Etype r;
  
}
class Mult:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Data{}
class Var:Etype{}
class Const:Etype{}


class Program {
    static object Run() {
              
        Var []env = new Var[3];
        Var v1 = null;
        Var v2 = null;
        
        env[0] = v1;
        env[0] = v2;
        
        Const c1 = new Const();
        Const c2 = new Const();
       
        

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        
        
        var exp = ad1;        
        
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
        return new { root = exp , variable = env };
        
        
    }
}

HeapDbg/ve

// Creates an array of un-aliased Data objects
class Data { }
class Program {
    static object Run() {
        var res = new Data[10];
        for (int i = 0; i < res.Length; ++i) {
            res[i] = new Data();
            res[i] = new Data();
        }
        return new { root = res };
    }
}

HeapDbg/VC

// Creates an array of un-aliased Data objects, some entries are null.
public class Program
    {
        Program f;
        public static object Run(Program param)
        {
            Program local1 = bar();
            Program local2 = bar();
            local1.f = param;
            local2.f = new Program();
            local2.f.f = new Program();
            return  local1;
        }

        public static Program bar()
        {
            Program r = new Program();
            return r;
        }
    }

HeapDbg/v2

// Creates an array of un-aliased Data objects
class Etype { 
  
    public double value;
    public void setValue(double x)
    {
      value = x;
    }
    public double getValue()
    {
      return value;
    }
  }

class Add:Etype{
  
  Etype l;
  Etype r;
  double getVal()
  {
    return (l.getValue()+r.getValue());    
  }
}

class Data{}

class Program {
    static object Run() {
        var res = new Data[10];
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
        return new { root = res };
    }
}

HeapDbg/PW

// Create a LinkedList of Data objects
// Self edge on, Next, and label, List
class Data { }
class ListNode { public ListNode Next; public Data Data; }
class Program {
    static object Run() {
        ListNode res = null;
        ListNode res_init = null;
        for (int i = 0; i < 10; ++i)
{            res = new ListNode { Next = res, Data = new Data() };
if (i==3) res_init=res;}
        return new { root = res_init };
    }
}

HeapDbg/pq

// Create a LinkedList of Data objects
// Self edge on, Next, and label, List
class Data { }
class X: Data { }
class Y: Data { }
class ListNode { public ListNode Next, Prev; public Data Data; }
class Program {
    static object Run() {
        ListNode res = null;
        for (int i = 0; i < 10; ++i) {
            res = new ListNode { Next = res, Data = new X() };
        }
        while(res != null) {
            if (res.Next != null)
                res.Next.Prev = res;
                res = res.Next;
        }
        return new { root = res };
    }
}

HeapDbg/plS

// Creates an array of un-aliased Data objects

class Program {
    static object Run() {
        return null;
    }
}

HeapDbg/fq

g3bTWi  <a href="http://kwhlydxupgfx.com/">kwhlydxupgfx</a>, [url=http://fkbwpuvazltj.com/]fkbwpuvazltj[/url], [link=http://cpxhfjpzghom.com/]cpxhfjpzghom[/link], http://qeixermbablr.com/

HeapDbg/DY

// Creates an array of un-aliased Data objects
class Data { }
class Program {
    static object Run() {
        var res = new Data[20];
        for (int i = 0; i < res.Length; ++i)
            res[i] = new Data();
        return new { root = res };
    }
}

HeapDbg/dx3D

// Creates an array of un-aliased Data objects
class Etype { 
  
    public double value;
    public void setValue(double x)
    {
      value = x;
    }
}

class Add:Etype{
  
  public Etype l;
  public Etype r;
  
  
}

class Sub:Etype{
  
  public Etype l;
  public Etype r;
  
}
class Mult:Etype{
  
  public Etype l;
  public Etype r;
  
}

class Data{}
class Var:Etype{
  
  public Etype arrayIndex;
}
class Const:Etype{}


class Program {
    static object Run() {
              
        Var []env = new Var[3];
        
        Var v1= new Var();
        Var v2= new Var();
        Var v3= new Var();
        
        env[0] = v1;
        env[1] = v2;
        Const c1 = new Const();
        Const c2 = new Const();
       
        

        Sub sb  = new Sub();
        sb.r = v1;
        sb.l = v2;
        
        Add ad2 = new Add();
        ad2.l = v2;
        ad2.r = c1;
        
        Mult mt = new Mult();
        mt.l = ad2;
        mt.r = sb;
        
        Add ad1 = new Add();
        ad1.l = mt;
        ad1.r = c2;
        
        var exp = ad1;        
        
        
        return new { root = exp , v = env };
        
        
    }
}