// generated file, do not modify!
// 2016-03-21T13:14:17.421561000000Z

using System;
using System.Linq;
using System.Collections.Generic;
using Newtonsoft.Json.Linq;


namespace LambdaCube.IR {
  class ArrayValue {
      public enum Tag { 
        VBoolArray,
        VIntArray,
        VWordArray,
        VFloatArray
      };
      public Tag tag;
  };

  namespace data { 
    class VBoolArray : LambdaCube.IR.ArrayValue { 
      public List<bool> _0;
      public VBoolArray() { tag = LambdaCube.IR.ArrayValue.Tag.VBoolArray; }
    };
    class VIntArray : LambdaCube.IR.ArrayValue { 
      public List<int> _0;
      public VIntArray() { tag = LambdaCube.IR.ArrayValue.Tag.VIntArray; }
    };
    class VWordArray : LambdaCube.IR.ArrayValue { 
      public List<uint> _0;
      public VWordArray() { tag = LambdaCube.IR.ArrayValue.Tag.VWordArray; }
    };
    class VFloatArray : LambdaCube.IR.ArrayValue { 
      public List<float> _0;
      public VFloatArray() { tag = LambdaCube.IR.ArrayValue.Tag.VFloatArray; }
    };
  }
  class Value {
      public enum Tag { 
        VBool,
        VV2B,
        VV3B,
        VV4B,
        VWord,
        VV2U,
        VV3U,
        VV4U,
        VInt,
        VV2I,
        VV3I,
        VV4I,
        VFloat,
        VV2F,
        VV3F,
        VV4F,
        VM22F,
        VM23F,
        VM24F,
        VM32F,
        VM33F,
        VM34F,
        VM42F,
        VM43F,
        VM44F
      };
      public Tag tag;
  };

  namespace data { 
    class VBool : LambdaCube.IR.Value { 
      public bool _0;
      public VBool() { tag = LambdaCube.IR.Value.Tag.VBool; }
    };
    class VV2B : LambdaCube.IR.Value { 
      public V2<bool> _0;
      public VV2B() { tag = LambdaCube.IR.Value.Tag.VV2B; }
    };
    class VV3B : LambdaCube.IR.Value { 
      public V3<bool> _0;
      public VV3B() { tag = LambdaCube.IR.Value.Tag.VV3B; }
    };
    class VV4B : LambdaCube.IR.Value { 
      public V4<bool> _0;
      public VV4B() { tag = LambdaCube.IR.Value.Tag.VV4B; }
    };
    class VWord : LambdaCube.IR.Value { 
      public uint _0;
      public VWord() { tag = LambdaCube.IR.Value.Tag.VWord; }
    };
    class VV2U : LambdaCube.IR.Value { 
      public V2<uint> _0;
      public VV2U() { tag = LambdaCube.IR.Value.Tag.VV2U; }
    };
    class VV3U : LambdaCube.IR.Value { 
      public V3<uint> _0;
      public VV3U() { tag = LambdaCube.IR.Value.Tag.VV3U; }
    };
    class VV4U : LambdaCube.IR.Value { 
      public V4<uint> _0;
      public VV4U() { tag = LambdaCube.IR.Value.Tag.VV4U; }
    };
    class VInt : LambdaCube.IR.Value { 
      public int _0;
      public VInt() { tag = LambdaCube.IR.Value.Tag.VInt; }
    };
    class VV2I : LambdaCube.IR.Value { 
      public V2<int> _0;
      public VV2I() { tag = LambdaCube.IR.Value.Tag.VV2I; }
    };
    class VV3I : LambdaCube.IR.Value { 
      public V3<int> _0;
      public VV3I() { tag = LambdaCube.IR.Value.Tag.VV3I; }
    };
    class VV4I : LambdaCube.IR.Value { 
      public V4<int> _0;
      public VV4I() { tag = LambdaCube.IR.Value.Tag.VV4I; }
    };
    class VFloat : LambdaCube.IR.Value { 
      public float _0;
      public VFloat() { tag = LambdaCube.IR.Value.Tag.VFloat; }
    };
    class VV2F : LambdaCube.IR.Value { 
      public V2<float> _0;
      public VV2F() { tag = LambdaCube.IR.Value.Tag.VV2F; }
    };
    class VV3F : LambdaCube.IR.Value { 
      public V3<float> _0;
      public VV3F() { tag = LambdaCube.IR.Value.Tag.VV3F; }
    };
    class VV4F : LambdaCube.IR.Value { 
      public V4<float> _0;
      public VV4F() { tag = LambdaCube.IR.Value.Tag.VV4F; }
    };
    class VM22F : LambdaCube.IR.Value { 
      public V2<V2<float>> _0;
      public VM22F() { tag = LambdaCube.IR.Value.Tag.VM22F; }
    };
    class VM23F : LambdaCube.IR.Value { 
      public V3<V2<float>> _0;
      public VM23F() { tag = LambdaCube.IR.Value.Tag.VM23F; }
    };
    class VM24F : LambdaCube.IR.Value { 
      public V4<V2<float>> _0;
      public VM24F() { tag = LambdaCube.IR.Value.Tag.VM24F; }
    };
    class VM32F : LambdaCube.IR.Value { 
      public V2<V3<float>> _0;
      public VM32F() { tag = LambdaCube.IR.Value.Tag.VM32F; }
    };
    class VM33F : LambdaCube.IR.Value { 
      public V3<V3<float>> _0;
      public VM33F() { tag = LambdaCube.IR.Value.Tag.VM33F; }
    };
    class VM34F : LambdaCube.IR.Value { 
      public V4<V3<float>> _0;
      public VM34F() { tag = LambdaCube.IR.Value.Tag.VM34F; }
    };
    class VM42F : LambdaCube.IR.Value { 
      public V2<V4<float>> _0;
      public VM42F() { tag = LambdaCube.IR.Value.Tag.VM42F; }
    };
    class VM43F : LambdaCube.IR.Value { 
      public V3<V4<float>> _0;
      public VM43F() { tag = LambdaCube.IR.Value.Tag.VM43F; }
    };
    class VM44F : LambdaCube.IR.Value { 
      public V4<V4<float>> _0;
      public VM44F() { tag = LambdaCube.IR.Value.Tag.VM44F; }
    };
  }
  class InputType {
      public enum Tag { 
        Bool,
        V2B,
        V3B,
        V4B,
        Word,
        V2U,
        V3U,
        V4U,
        Int,
        V2I,
        V3I,
        V4I,
        Float,
        V2F,
        V3F,
        V4F,
        M22F,
        M23F,
        M24F,
        M32F,
        M33F,
        M34F,
        M42F,
        M43F,
        M44F,
        STexture1D,
        STexture2D,
        STextureCube,
        STexture1DArray,
        STexture2DArray,
        STexture2DRect,
        FTexture1D,
        FTexture2D,
        FTexture3D,
        FTextureCube,
        FTexture1DArray,
        FTexture2DArray,
        FTexture2DMS,
        FTexture2DMSArray,
        FTextureBuffer,
        FTexture2DRect,
        ITexture1D,
        ITexture2D,
        ITexture3D,
        ITextureCube,
        ITexture1DArray,
        ITexture2DArray,
        ITexture2DMS,
        ITexture2DMSArray,
        ITextureBuffer,
        ITexture2DRect,
        UTexture1D,
        UTexture2D,
        UTexture3D,
        UTextureCube,
        UTexture1DArray,
        UTexture2DArray,
        UTexture2DMS,
        UTexture2DMSArray,
        UTextureBuffer,
        UTexture2DRect
      };
      public Tag tag;
  };

  namespace data { 
  }
  class PointSpriteCoordOrigin {
      public enum Tag { 
        LowerLeft,
        UpperLeft
      };
      public Tag tag;
  };

  namespace data { 
  }
  class PointSize {
      public enum Tag { 
        PointSize,
        ProgramPointSize
      };
      public Tag tag;
  };

  namespace data { 
    class PointSize : LambdaCube.IR.PointSize { 
      public float _0;
      public PointSize() { tag = LambdaCube.IR.PointSize.Tag.PointSize; }
    };
  }
  class PolygonOffset {
      public enum Tag { 
        NoOffset,
        Offset
      };
      public Tag tag;
  };

  namespace data { 
    class Offset : LambdaCube.IR.PolygonOffset { 
      public float _0;
      public float _1;
      public Offset() { tag = LambdaCube.IR.PolygonOffset.Tag.Offset; }
    };
  }
  class FrontFace {
      public enum Tag { 
        CCW,
        CW
      };
      public Tag tag;
  };

  namespace data { 
  }
  class PolygonMode {
      public enum Tag { 
        PolygonPoint,
        PolygonLine,
        PolygonFill
      };
      public Tag tag;
  };

  namespace data { 
    class PolygonPoint : LambdaCube.IR.PolygonMode { 
      public global::LambdaCube.IR.PointSize _0;
      public PolygonPoint() { tag = LambdaCube.IR.PolygonMode.Tag.PolygonPoint; }
    };
    class PolygonLine : LambdaCube.IR.PolygonMode { 
      public float _0;
      public PolygonLine() { tag = LambdaCube.IR.PolygonMode.Tag.PolygonLine; }
    };
  }
  class ProvokingVertex {
      public enum Tag { 
        FirstVertex,
        LastVertex
      };
      public Tag tag;
  };

  namespace data { 
  }
  class CullMode {
      public enum Tag { 
        CullNone,
        CullFront,
        CullBack
      };
      public Tag tag;
  };

  namespace data { 
    class CullFront : LambdaCube.IR.CullMode { 
      public global::LambdaCube.IR.FrontFace _0;
      public CullFront() { tag = LambdaCube.IR.CullMode.Tag.CullFront; }
    };
    class CullBack : LambdaCube.IR.CullMode { 
      public global::LambdaCube.IR.FrontFace _0;
      public CullBack() { tag = LambdaCube.IR.CullMode.Tag.CullBack; }
    };
  }
  class ComparisonFunction {
      public enum Tag { 
        Never,
        Less,
        Equal,
        Lequal,
        Greater,
        Notequal,
        Gequal,
        Always
      };
      public Tag tag;
  };

  namespace data { 
  }
  class StencilOperation {
      public enum Tag { 
        OpZero,
        OpKeep,
        OpReplace,
        OpIncr,
        OpIncrWrap,
        OpDecr,
        OpDecrWrap,
        OpInvert
      };
      public Tag tag;
  };

  namespace data { 
  }
  class BlendEquation {
      public enum Tag { 
        FuncAdd,
        FuncSubtract,
        FuncReverseSubtract,
        Min,
        Max
      };
      public Tag tag;
  };

  namespace data { 
  }
  class BlendingFactor {
      public enum Tag { 
        Zero,
        One,
        SrcColor,
        OneMinusSrcColor,
        DstColor,
        OneMinusDstColor,
        SrcAlpha,
        OneMinusSrcAlpha,
        DstAlpha,
        OneMinusDstAlpha,
        ConstantColor,
        OneMinusConstantColor,
        ConstantAlpha,
        OneMinusConstantAlpha,
        SrcAlphaSaturate
      };
      public Tag tag;
  };

  namespace data { 
  }
  class LogicOperation {
      public enum Tag { 
        Clear,
        And,
        AndReverse,
        Copy,
        AndInverted,
        Noop,
        Xor,
        Or,
        Nor,
        Equiv,
        Invert,
        OrReverse,
        CopyInverted,
        OrInverted,
        Nand,
        Set
      };
      public Tag tag;
  };

  namespace data { 
  }
  class StencilOps {
      public enum Tag { 
        StencilOps
      };
      public Tag tag;
  };

  namespace data { 
    class StencilOps : LambdaCube.IR.StencilOps { 
      public global::LambdaCube.IR.StencilOperation frontStencilOp;
      public global::LambdaCube.IR.StencilOperation backStencilOp;
      public StencilOps() { tag = LambdaCube.IR.StencilOps.Tag.StencilOps; }
    };
  }
  class StencilTest {
      public enum Tag { 
        StencilTest
      };
      public Tag tag;
  };

  namespace data { 
    class StencilTest : LambdaCube.IR.StencilTest { 
      public global::LambdaCube.IR.ComparisonFunction stencilComparision;
      public int stencilReference;
      public uint stencilMask;
      public StencilTest() { tag = LambdaCube.IR.StencilTest.Tag.StencilTest; }
    };
  }
  class StencilTests {
      public enum Tag { 
        StencilTests
      };
      public Tag tag;
  };

  namespace data { 
    class StencilTests : LambdaCube.IR.StencilTests { 
      public global::LambdaCube.IR.StencilTest _0;
      public global::LambdaCube.IR.StencilTest _1;
      public StencilTests() { tag = LambdaCube.IR.StencilTests.Tag.StencilTests; }
    };
  }
  class FetchPrimitive {
      public enum Tag { 
        Points,
        Lines,
        Triangles,
        LinesAdjacency,
        TrianglesAdjacency
      };
      public Tag tag;
  };

  namespace data { 
  }
  class OutputPrimitive {
      public enum Tag { 
        TrianglesOutput,
        LinesOutput,
        PointsOutput
      };
      public Tag tag;
  };

  namespace data { 
  }
  class ColorArity {
      public enum Tag { 
        Red,
        RG,
        RGB,
        RGBA
      };
      public Tag tag;
  };

  namespace data { 
  }
  class Blending {
      public enum Tag { 
        NoBlending,
        BlendLogicOp,
        Blend
      };
      public Tag tag;
  };

  namespace data { 
    class BlendLogicOp : LambdaCube.IR.Blending { 
      public global::LambdaCube.IR.LogicOperation _0;
      public BlendLogicOp() { tag = LambdaCube.IR.Blending.Tag.BlendLogicOp; }
    };
    class Blend : LambdaCube.IR.Blending { 
      public global::LambdaCube.IR.BlendEquation colorEqSrc;
      public global::LambdaCube.IR.BlendEquation alphaEqSrc;
      public global::LambdaCube.IR.BlendingFactor colorFSrc;
      public global::LambdaCube.IR.BlendingFactor colorFDst;
      public global::LambdaCube.IR.BlendingFactor alphaFSrc;
      public global::LambdaCube.IR.BlendingFactor alphaFDst;
      public V4<float> color;
      public Blend() { tag = LambdaCube.IR.Blending.Tag.Blend; }
    };
  }
  class RasterContext {
      public enum Tag { 
        PointCtx,
        LineCtx,
        TriangleCtx
      };
      public Tag tag;
  };

  namespace data { 
    class PointCtx : LambdaCube.IR.RasterContext { 
      public global::LambdaCube.IR.PointSize _0;
      public float _1;
      public global::LambdaCube.IR.PointSpriteCoordOrigin _2;
      public PointCtx() { tag = LambdaCube.IR.RasterContext.Tag.PointCtx; }
    };
    class LineCtx : LambdaCube.IR.RasterContext { 
      public float _0;
      public global::LambdaCube.IR.ProvokingVertex _1;
      public LineCtx() { tag = LambdaCube.IR.RasterContext.Tag.LineCtx; }
    };
    class TriangleCtx : LambdaCube.IR.RasterContext { 
      public global::LambdaCube.IR.CullMode _0;
      public global::LambdaCube.IR.PolygonMode _1;
      public global::LambdaCube.IR.PolygonOffset _2;
      public global::LambdaCube.IR.ProvokingVertex _3;
      public TriangleCtx() { tag = LambdaCube.IR.RasterContext.Tag.TriangleCtx; }
    };
  }
  class FragmentOperation {
      public enum Tag { 
        DepthOp,
        StencilOp,
        ColorOp
      };
      public Tag tag;
  };

  namespace data { 
    class DepthOp : LambdaCube.IR.FragmentOperation { 
      public global::LambdaCube.IR.ComparisonFunction _0;
      public bool _1;
      public DepthOp() { tag = LambdaCube.IR.FragmentOperation.Tag.DepthOp; }
    };
    class StencilOp : LambdaCube.IR.FragmentOperation { 
      public global::LambdaCube.IR.StencilTests _0;
      public global::LambdaCube.IR.StencilOps _1;
      public global::LambdaCube.IR.StencilOps _2;
      public StencilOp() { tag = LambdaCube.IR.FragmentOperation.Tag.StencilOp; }
    };
    class ColorOp : LambdaCube.IR.FragmentOperation { 
      public global::LambdaCube.IR.Blending _0;
      public global::LambdaCube.IR.Value _1;
      public ColorOp() { tag = LambdaCube.IR.FragmentOperation.Tag.ColorOp; }
    };
  }
  class AccumulationContext {
      public enum Tag { 
        AccumulationContext
      };
      public Tag tag;
  };

  namespace data { 
    class AccumulationContext : LambdaCube.IR.AccumulationContext { 
      public Maybe<string> accViewportName;
      public List<global::LambdaCube.IR.FragmentOperation> accOperations;
      public AccumulationContext() { tag = LambdaCube.IR.AccumulationContext.Tag.AccumulationContext; }
    };
  }
  class TextureDataType {
      public enum Tag { 
        FloatT,
        IntT,
        WordT,
        ShadowT
      };
      public Tag tag;
  };

  namespace data { 
    class FloatT : LambdaCube.IR.TextureDataType { 
      public global::LambdaCube.IR.ColorArity _0;
      public FloatT() { tag = LambdaCube.IR.TextureDataType.Tag.FloatT; }
    };
    class IntT : LambdaCube.IR.TextureDataType { 
      public global::LambdaCube.IR.ColorArity _0;
      public IntT() { tag = LambdaCube.IR.TextureDataType.Tag.IntT; }
    };
    class WordT : LambdaCube.IR.TextureDataType { 
      public global::LambdaCube.IR.ColorArity _0;
      public WordT() { tag = LambdaCube.IR.TextureDataType.Tag.WordT; }
    };
  }
  class TextureType {
      public enum Tag { 
        Texture1D,
        Texture2D,
        Texture3D,
        TextureCube,
        TextureRect,
        Texture2DMS,
        TextureBuffer
      };
      public Tag tag;
  };

  namespace data { 
    class Texture1D : LambdaCube.IR.TextureType { 
      public global::LambdaCube.IR.TextureDataType _0;
      public int _1;
      public Texture1D() { tag = LambdaCube.IR.TextureType.Tag.Texture1D; }
    };
    class Texture2D : LambdaCube.IR.TextureType { 
      public global::LambdaCube.IR.TextureDataType _0;
      public int _1;
      public Texture2D() { tag = LambdaCube.IR.TextureType.Tag.Texture2D; }
    };
    class Texture3D : LambdaCube.IR.TextureType { 
      public global::LambdaCube.IR.TextureDataType _0;
      public Texture3D() { tag = LambdaCube.IR.TextureType.Tag.Texture3D; }
    };
    class TextureCube : LambdaCube.IR.TextureType { 
      public global::LambdaCube.IR.TextureDataType _0;
      public TextureCube() { tag = LambdaCube.IR.TextureType.Tag.TextureCube; }
    };
    class TextureRect : LambdaCube.IR.TextureType { 
      public global::LambdaCube.IR.TextureDataType _0;
      public TextureRect() { tag = LambdaCube.IR.TextureType.Tag.TextureRect; }
    };
    class Texture2DMS : LambdaCube.IR.TextureType { 
      public global::LambdaCube.IR.TextureDataType _0;
      public int _1;
      public int _2;
      public bool _3;
      public Texture2DMS() { tag = LambdaCube.IR.TextureType.Tag.Texture2DMS; }
    };
    class TextureBuffer : LambdaCube.IR.TextureType { 
      public global::LambdaCube.IR.TextureDataType _0;
      public TextureBuffer() { tag = LambdaCube.IR.TextureType.Tag.TextureBuffer; }
    };
  }
  class MipMap {
      public enum Tag { 
        Mip,
        NoMip,
        AutoMip
      };
      public Tag tag;
  };

  namespace data { 
    class Mip : LambdaCube.IR.MipMap { 
      public int _0;
      public int _1;
      public Mip() { tag = LambdaCube.IR.MipMap.Tag.Mip; }
    };
    class AutoMip : LambdaCube.IR.MipMap { 
      public int _0;
      public int _1;
      public AutoMip() { tag = LambdaCube.IR.MipMap.Tag.AutoMip; }
    };
  }
  class Filter {
      public enum Tag { 
        Nearest,
        Linear,
        NearestMipmapNearest,
        NearestMipmapLinear,
        LinearMipmapNearest,
        LinearMipmapLinear
      };
      public Tag tag;
  };

  namespace data { 
  }
  class EdgeMode {
      public enum Tag { 
        Repeat,
        MirroredRepeat,
        ClampToEdge,
        ClampToBorder
      };
      public Tag tag;
  };

  namespace data { 
  }
  class ImageSemantic {
      public enum Tag { 
        Depth,
        Stencil,
        Color
      };
      public Tag tag;
  };

  namespace data { 
  }
  class ImageRef {
      public enum Tag { 
        TextureImage,
        Framebuffer
      };
      public Tag tag;
  };

  namespace data { 
    class TextureImage : LambdaCube.IR.ImageRef { 
      public int _0;
      public int _1;
      public Maybe<int> _2;
      public TextureImage() { tag = LambdaCube.IR.ImageRef.Tag.TextureImage; }
    };
    class Framebuffer : LambdaCube.IR.ImageRef { 
      public global::LambdaCube.IR.ImageSemantic _0;
      public Framebuffer() { tag = LambdaCube.IR.ImageRef.Tag.Framebuffer; }
    };
  }
  class ClearImage {
      public enum Tag { 
        ClearImage
      };
      public Tag tag;
  };

  namespace data { 
    class ClearImage : LambdaCube.IR.ClearImage { 
      public global::LambdaCube.IR.ImageSemantic imageSemantic;
      public global::LambdaCube.IR.Value clearValue;
      public ClearImage() { tag = LambdaCube.IR.ClearImage.Tag.ClearImage; }
    };
  }
  class Command {
      public enum Tag { 
        SetRasterContext,
        SetAccumulationContext,
        SetRenderTarget,
        SetProgram,
        SetSamplerUniform,
        SetTexture,
        SetSampler,
        RenderSlot,
        RenderStream,
        ClearRenderTarget,
        GenerateMipMap,
        SaveImage,
        LoadImage
      };
      public Tag tag;
  };

  namespace data { 
    class SetRasterContext : LambdaCube.IR.Command { 
      public global::LambdaCube.IR.RasterContext _0;
      public SetRasterContext() { tag = LambdaCube.IR.Command.Tag.SetRasterContext; }
    };
    class SetAccumulationContext : LambdaCube.IR.Command { 
      public global::LambdaCube.IR.AccumulationContext _0;
      public SetAccumulationContext() { tag = LambdaCube.IR.Command.Tag.SetAccumulationContext; }
    };
    class SetRenderTarget : LambdaCube.IR.Command { 
      public int _0;
      public SetRenderTarget() { tag = LambdaCube.IR.Command.Tag.SetRenderTarget; }
    };
    class SetProgram : LambdaCube.IR.Command { 
      public int _0;
      public SetProgram() { tag = LambdaCube.IR.Command.Tag.SetProgram; }
    };
    class SetSamplerUniform : LambdaCube.IR.Command { 
      public string _0;
      public int _1;
      public SetSamplerUniform() { tag = LambdaCube.IR.Command.Tag.SetSamplerUniform; }
    };
    class SetTexture : LambdaCube.IR.Command { 
      public int _0;
      public int _1;
      public SetTexture() { tag = LambdaCube.IR.Command.Tag.SetTexture; }
    };
    class SetSampler : LambdaCube.IR.Command { 
      public int _0;
      public Maybe<int> _1;
      public SetSampler() { tag = LambdaCube.IR.Command.Tag.SetSampler; }
    };
    class RenderSlot : LambdaCube.IR.Command { 
      public int _0;
      public RenderSlot() { tag = LambdaCube.IR.Command.Tag.RenderSlot; }
    };
    class RenderStream : LambdaCube.IR.Command { 
      public int _0;
      public RenderStream() { tag = LambdaCube.IR.Command.Tag.RenderStream; }
    };
    class ClearRenderTarget : LambdaCube.IR.Command { 
      public List<global::LambdaCube.IR.ClearImage> _0;
      public ClearRenderTarget() { tag = LambdaCube.IR.Command.Tag.ClearRenderTarget; }
    };
    class GenerateMipMap : LambdaCube.IR.Command { 
      public int _0;
      public GenerateMipMap() { tag = LambdaCube.IR.Command.Tag.GenerateMipMap; }
    };
    class SaveImage : LambdaCube.IR.Command { 
      public int _0;
      public global::LambdaCube.IR.ImageRef _1;
      public SaveImage() { tag = LambdaCube.IR.Command.Tag.SaveImage; }
    };
    class LoadImage : LambdaCube.IR.Command { 
      public global::LambdaCube.IR.ImageRef _0;
      public int _1;
      public LoadImage() { tag = LambdaCube.IR.Command.Tag.LoadImage; }
    };
  }
  class SamplerDescriptor {
      public enum Tag { 
        SamplerDescriptor
      };
      public Tag tag;
  };

  namespace data { 
    class SamplerDescriptor : LambdaCube.IR.SamplerDescriptor { 
      public global::LambdaCube.IR.EdgeMode samplerWrapS;
      public Maybe<global::LambdaCube.IR.EdgeMode> samplerWrapT;
      public Maybe<global::LambdaCube.IR.EdgeMode> samplerWrapR;
      public global::LambdaCube.IR.Filter samplerMinFilter;
      public global::LambdaCube.IR.Filter samplerMagFilter;
      public global::LambdaCube.IR.Value samplerBorderColor;
      public Maybe<float> samplerMinLod;
      public Maybe<float> samplerMaxLod;
      public float samplerLodBias;
      public Maybe<global::LambdaCube.IR.ComparisonFunction> samplerCompareFunc;
      public SamplerDescriptor() { tag = LambdaCube.IR.SamplerDescriptor.Tag.SamplerDescriptor; }
    };
  }
  class TextureDescriptor {
      public enum Tag { 
        TextureDescriptor
      };
      public Tag tag;
  };

  namespace data { 
    class TextureDescriptor : LambdaCube.IR.TextureDescriptor { 
      public global::LambdaCube.IR.TextureType textureType;
      public global::LambdaCube.IR.Value textureSize;
      public global::LambdaCube.IR.ImageSemantic textureSemantic;
      public global::LambdaCube.IR.SamplerDescriptor textureSampler;
      public int textureBaseLevel;
      public int textureMaxLevel;
      public TextureDescriptor() { tag = LambdaCube.IR.TextureDescriptor.Tag.TextureDescriptor; }
    };
  }
  class Parameter {
      public enum Tag { 
        Parameter
      };
      public Tag tag;
  };

  namespace data { 
    class Parameter : LambdaCube.IR.Parameter { 
      public string name;
      public global::LambdaCube.IR.InputType ty;
      public Parameter() { tag = LambdaCube.IR.Parameter.Tag.Parameter; }
    };
  }
  class Program {
      public enum Tag { 
        Program
      };
      public Tag tag;
  };

  namespace data { 
    class Program : LambdaCube.IR.Program { 
      public Dictionary<string, global::LambdaCube.IR.InputType> programUniforms;
      public Dictionary<string, global::LambdaCube.IR.Parameter> programStreams;
      public Dictionary<string, global::LambdaCube.IR.InputType> programInTextures;
      public List<global::LambdaCube.IR.Parameter> programOutput;
      public string vertexShader;
      public Maybe<string> geometryShader;
      public string fragmentShader;
      public Program() { tag = LambdaCube.IR.Program.Tag.Program; }
    };
  }
  class Slot {
      public enum Tag { 
        Slot
      };
      public Tag tag;
  };

  namespace data { 
    class Slot : LambdaCube.IR.Slot { 
      public string slotName;
      public Dictionary<string, global::LambdaCube.IR.InputType> slotStreams;
      public Dictionary<string, global::LambdaCube.IR.InputType> slotUniforms;
      public global::LambdaCube.IR.FetchPrimitive slotPrimitive;
      public List<int> slotPrograms;
      public Slot() { tag = LambdaCube.IR.Slot.Tag.Slot; }
    };
  }
  class StreamData {
      public enum Tag { 
        StreamData
      };
      public Tag tag;
  };

  namespace data { 
    class StreamData : LambdaCube.IR.StreamData { 
      public Dictionary<string, global::LambdaCube.IR.ArrayValue> streamData;
      public Dictionary<string, global::LambdaCube.IR.InputType> streamType;
      public global::LambdaCube.IR.FetchPrimitive streamPrimitive;
      public List<int> streamPrograms;
      public StreamData() { tag = LambdaCube.IR.StreamData.Tag.StreamData; }
    };
  }
  class TargetItem {
      public enum Tag { 
        TargetItem
      };
      public Tag tag;
  };

  namespace data { 
    class TargetItem : LambdaCube.IR.TargetItem { 
      public global::LambdaCube.IR.ImageSemantic targetSemantic;
      public Maybe<global::LambdaCube.IR.ImageRef> targetRef;
      public TargetItem() { tag = LambdaCube.IR.TargetItem.Tag.TargetItem; }
    };
  }
  class RenderTarget {
      public enum Tag { 
        RenderTarget
      };
      public Tag tag;
  };

  namespace data { 
    class RenderTarget : LambdaCube.IR.RenderTarget { 
      public List<global::LambdaCube.IR.TargetItem> renderTargets;
      public RenderTarget() { tag = LambdaCube.IR.RenderTarget.Tag.RenderTarget; }
    };
  }
  class Backend {
      public enum Tag { 
        WebGL1,
        OpenGL33
      };
      public Tag tag;
  };

  namespace data { 
  }
  class Pipeline {
      public enum Tag { 
        Pipeline
      };
      public Tag tag;
  };

  namespace data { 
    class Pipeline : LambdaCube.IR.Pipeline { 
      public string info;
      public global::LambdaCube.IR.Backend backend;
      public List<global::LambdaCube.IR.TextureDescriptor> textures;
      public List<global::LambdaCube.IR.SamplerDescriptor> samplers;
      public List<global::LambdaCube.IR.RenderTarget> targets;
      public List<global::LambdaCube.IR.Program> programs;
      public List<global::LambdaCube.IR.Slot> slots;
      public List<global::LambdaCube.IR.StreamData> streams;
      public List<global::LambdaCube.IR.Command> commands;
      public Pipeline() { tag = LambdaCube.IR.Pipeline.Tag.Pipeline; }
    };
  }

  // JSON deserializer
  enum Type { 
    Int,
    Int32,
    Word,
    Word32,
    Float,
    Bool,
    String,
    V2_Int,
    V2_Word,
    V2_Float,
    V2_Bool,
    V2_V2_Float,
    V2_V3_Float,
    V2_V4_Float,
    V3_Int,
    V3_Word,
    V3_Float,
    V3_Bool,
    V3_V2_Float,
    V3_V3_Float,
    V3_V4_Float,
    V4_Int,
    V4_Word,
    V4_Float,
    V4_Bool,
    V4_V2_Float,
    V4_V3_Float,
    V4_V4_Float,
    Array_Int,
    Array_Int32,
    Array_Word32,
    Array_Float,
    Array_Bool,
    Array_ClearImage,
    Array_Command,
    Array_Parameter,
    Array_Program,
    Array_RenderTarget,
    Array_SamplerDescriptor,
    Array_Slot,
    Array_StreamData,
    Array_TargetItem,
    Array_TextureDescriptor,
    List_FragmentOperation,
    Maybe_Int,
    Maybe_Float,
    Maybe_String,
    Maybe_ComparisonFunction,
    Maybe_EdgeMode,
    Maybe_ImageRef,
    Map_String_ArrayValue,
    Map_String_InputType,
    Map_String_Parameter,
    AccumulationContext,
    ArrayValue,
    Backend,
    BlendEquation,
    Blending,
    BlendingFactor,
    ClearImage,
    ColorArity,
    Command,
    ComparisonFunction,
    CullMode,
    EdgeMode,
    FetchPrimitive,
    Filter,
    FragmentOperation,
    FrontFace,
    ImageRef,
    ImageSemantic,
    InputType,
    LogicOperation,
    MipMap,
    OutputPrimitive,
    Parameter,
    Pipeline,
    PointSize,
    PointSpriteCoordOrigin,
    PolygonMode,
    PolygonOffset,
    Program,
    ProvokingVertex,
    RasterContext,
    RenderTarget,
    SamplerDescriptor,
    Slot,
    StencilOperation,
    StencilOps,
    StencilTest,
    StencilTests,
    StreamData,
    TargetItem,
    TextureDataType,
    TextureDescriptor,
    TextureType,
    Value
  }

  class Loader {
    public static object fromJSON(Type type, JToken obj) {
      switch (type) {
        case Type.Int: return (int)obj;
        case Type.Int32: return (int)obj;
        case Type.Word: return (uint)obj;
        case Type.Word32: return (uint)obj;
        case Type.Float: return (float)obj;
        case Type.Bool: return (bool)obj;
        case Type.String: return (string)obj;
        case Type.V2_Int:
          return new V2<int>
            { x = (int)fromJSON(Type.Int,obj["x"])
            , y = (int)fromJSON(Type.Int,obj["y"])
            };
        case Type.V2_Word:
          return new V2<uint>
            { x = (uint)fromJSON(Type.Word,obj["x"])
            , y = (uint)fromJSON(Type.Word,obj["y"])
            };
        case Type.V2_Float:
          return new V2<float>
            { x = (float)fromJSON(Type.Float,obj["x"])
            , y = (float)fromJSON(Type.Float,obj["y"])
            };
        case Type.V2_Bool:
          return new V2<bool>
            { x = (bool)fromJSON(Type.Bool,obj["x"])
            , y = (bool)fromJSON(Type.Bool,obj["y"])
            };
        case Type.V2_V2_Float:
          return new V2<V2<float>>
            { x = (V2<float>)fromJSON(Type.V2_Float,obj["x"])
            , y = (V2<float>)fromJSON(Type.V2_Float,obj["y"])
            };
        case Type.V2_V3_Float:
          return new V2<V3<float>>
            { x = (V3<float>)fromJSON(Type.V3_Float,obj["x"])
            , y = (V3<float>)fromJSON(Type.V3_Float,obj["y"])
            };
        case Type.V2_V4_Float:
          return new V2<V4<float>>
            { x = (V4<float>)fromJSON(Type.V4_Float,obj["x"])
            , y = (V4<float>)fromJSON(Type.V4_Float,obj["y"])
            };
        case Type.V3_Int:
          return new V3<int>
            { x = (int)fromJSON(Type.Int,obj["x"])
            , y = (int)fromJSON(Type.Int,obj["y"])
            , z = (int)fromJSON(Type.Int,obj["z"])
            };
        case Type.V3_Word:
          return new V3<uint>
            { x = (uint)fromJSON(Type.Word,obj["x"])
            , y = (uint)fromJSON(Type.Word,obj["y"])
            , z = (uint)fromJSON(Type.Word,obj["z"])
            };
        case Type.V3_Float:
          return new V3<float>
            { x = (float)fromJSON(Type.Float,obj["x"])
            , y = (float)fromJSON(Type.Float,obj["y"])
            , z = (float)fromJSON(Type.Float,obj["z"])
            };
        case Type.V3_Bool:
          return new V3<bool>
            { x = (bool)fromJSON(Type.Bool,obj["x"])
            , y = (bool)fromJSON(Type.Bool,obj["y"])
            , z = (bool)fromJSON(Type.Bool,obj["z"])
            };
        case Type.V3_V2_Float:
          return new V3<V2<float>>
            { x = (V2<float>)fromJSON(Type.V2_Float,obj["x"])
            , y = (V2<float>)fromJSON(Type.V2_Float,obj["y"])
            , z = (V2<float>)fromJSON(Type.V2_Float,obj["z"])
            };
        case Type.V3_V3_Float:
          return new V3<V3<float>>
            { x = (V3<float>)fromJSON(Type.V3_Float,obj["x"])
            , y = (V3<float>)fromJSON(Type.V3_Float,obj["y"])
            , z = (V3<float>)fromJSON(Type.V3_Float,obj["z"])
            };
        case Type.V3_V4_Float:
          return new V3<V4<float>>
            { x = (V4<float>)fromJSON(Type.V4_Float,obj["x"])
            , y = (V4<float>)fromJSON(Type.V4_Float,obj["y"])
            , z = (V4<float>)fromJSON(Type.V4_Float,obj["z"])
            };
        case Type.V4_Int:
          return new V4<int>
            { x = (int)fromJSON(Type.Int,obj["x"])
            , y = (int)fromJSON(Type.Int,obj["y"])
            , z = (int)fromJSON(Type.Int,obj["z"])
            , w = (int)fromJSON(Type.Int,obj["w"])
            };
        case Type.V4_Word:
          return new V4<uint>
            { x = (uint)fromJSON(Type.Word,obj["x"])
            , y = (uint)fromJSON(Type.Word,obj["y"])
            , z = (uint)fromJSON(Type.Word,obj["z"])
            , w = (uint)fromJSON(Type.Word,obj["w"])
            };
        case Type.V4_Float:
          return new V4<float>
            { x = (float)fromJSON(Type.Float,obj["x"])
            , y = (float)fromJSON(Type.Float,obj["y"])
            , z = (float)fromJSON(Type.Float,obj["z"])
            , w = (float)fromJSON(Type.Float,obj["w"])
            };
        case Type.V4_Bool:
          return new V4<bool>
            { x = (bool)fromJSON(Type.Bool,obj["x"])
            , y = (bool)fromJSON(Type.Bool,obj["y"])
            , z = (bool)fromJSON(Type.Bool,obj["z"])
            , w = (bool)fromJSON(Type.Bool,obj["w"])
            };
        case Type.V4_V2_Float:
          return new V4<V2<float>>
            { x = (V2<float>)fromJSON(Type.V2_Float,obj["x"])
            , y = (V2<float>)fromJSON(Type.V2_Float,obj["y"])
            , z = (V2<float>)fromJSON(Type.V2_Float,obj["z"])
            , w = (V2<float>)fromJSON(Type.V2_Float,obj["w"])
            };
        case Type.V4_V3_Float:
          return new V4<V3<float>>
            { x = (V3<float>)fromJSON(Type.V3_Float,obj["x"])
            , y = (V3<float>)fromJSON(Type.V3_Float,obj["y"])
            , z = (V3<float>)fromJSON(Type.V3_Float,obj["z"])
            , w = (V3<float>)fromJSON(Type.V3_Float,obj["w"])
            };
        case Type.V4_V4_Float:
          return new V4<V4<float>>
            { x = (V4<float>)fromJSON(Type.V4_Float,obj["x"])
            , y = (V4<float>)fromJSON(Type.V4_Float,obj["y"])
            , z = (V4<float>)fromJSON(Type.V4_Float,obj["z"])
            , w = (V4<float>)fromJSON(Type.V4_Float,obj["w"])
            };
        case Type.Array_Int: return ((JArray)obj).Select(x => fromJSON (Type.Int, x)).ToList();
        case Type.Array_Int32: return ((JArray)obj).Select(x => fromJSON (Type.Int32, x)).ToList();
        case Type.Array_Word32: return ((JArray)obj).Select(x => fromJSON (Type.Word32, x)).ToList();
        case Type.Array_Float: return ((JArray)obj).Select(x => fromJSON (Type.Float, x)).ToList();
        case Type.Array_Bool: return ((JArray)obj).Select(x => fromJSON (Type.Bool, x)).ToList();
        case Type.Array_ClearImage: return ((JArray)obj).Select(x => fromJSON (Type.ClearImage, x)).ToList();
        case Type.Array_Command: return ((JArray)obj).Select(x => fromJSON (Type.Command, x)).ToList();
        case Type.Array_Parameter: return ((JArray)obj).Select(x => fromJSON (Type.Parameter, x)).ToList();
        case Type.Array_Program: return ((JArray)obj).Select(x => fromJSON (Type.Program, x)).ToList();
        case Type.Array_RenderTarget: return ((JArray)obj).Select(x => fromJSON (Type.RenderTarget, x)).ToList();
        case Type.Array_SamplerDescriptor: return ((JArray)obj).Select(x => fromJSON (Type.SamplerDescriptor, x)).ToList();
        case Type.Array_Slot: return ((JArray)obj).Select(x => fromJSON (Type.Slot, x)).ToList();
        case Type.Array_StreamData: return ((JArray)obj).Select(x => fromJSON (Type.StreamData, x)).ToList();
        case Type.Array_TargetItem: return ((JArray)obj).Select(x => fromJSON (Type.TargetItem, x)).ToList();
        case Type.Array_TextureDescriptor: return ((JArray)obj).Select(x => fromJSON (Type.TextureDescriptor, x)).ToList();
        case Type.List_FragmentOperation: return ((JArray)obj).Select(x => fromJSON (Type.FragmentOperation, x)).ToList();
        case Type.Maybe_Int: {
          var m = new Maybe<int> ();
          if (obj == null || obj.Type == JTokenType.Null) {
            m.valid = false;
          } else {
            m.valid = true;
            m.data = (int)fromJSON (Type.Int,obj);
          }
          return m;
        }
        case Type.Maybe_Float: {
          var m = new Maybe<float> ();
          if (obj == null || obj.Type == JTokenType.Null) {
            m.valid = false;
          } else {
            m.valid = true;
            m.data = (float)fromJSON (Type.Float,obj);
          }
          return m;
        }
        case Type.Maybe_String: {
          var m = new Maybe<string> ();
          if (obj == null || obj.Type == JTokenType.Null) {
            m.valid = false;
          } else {
            m.valid = true;
            m.data = (string)fromJSON (Type.String,obj);
          }
          return m;
        }
        case Type.Maybe_ComparisonFunction: {
          var m = new Maybe<global::LambdaCube.IR.ComparisonFunction> ();
          if (obj == null || obj.Type == JTokenType.Null) {
            m.valid = false;
          } else {
            m.valid = true;
            m.data = (global::LambdaCube.IR.ComparisonFunction)fromJSON (Type.ComparisonFunction,obj);
          }
          return m;
        }
        case Type.Maybe_EdgeMode: {
          var m = new Maybe<global::LambdaCube.IR.EdgeMode> ();
          if (obj == null || obj.Type == JTokenType.Null) {
            m.valid = false;
          } else {
            m.valid = true;
            m.data = (global::LambdaCube.IR.EdgeMode)fromJSON (Type.EdgeMode,obj);
          }
          return m;
        }
        case Type.Maybe_ImageRef: {
          var m = new Maybe<global::LambdaCube.IR.ImageRef> ();
          if (obj == null || obj.Type == JTokenType.Null) {
            m.valid = false;
          } else {
            m.valid = true;
            m.data = (global::LambdaCube.IR.ImageRef)fromJSON (Type.ImageRef,obj);
          }
          return m;
        }
        case Type.Map_String_ArrayValue: {
          var map = new Dictionary<string, global::LambdaCube.IR.ArrayValue> ();
          foreach(var i in (JObject)obj) {
            map.Add( (string)fromJSON(Type.String,i.Key)
                   , (global::LambdaCube.IR.ArrayValue)fromJSON(Type.ArrayValue,i.Value));
          }
          return map;
        }
        case Type.Map_String_InputType: {
          var map = new Dictionary<string, global::LambdaCube.IR.InputType> ();
          foreach(var i in (JObject)obj) {
            map.Add( (string)fromJSON(Type.String,i.Key)
                   , (global::LambdaCube.IR.InputType)fromJSON(Type.InputType,i.Value));
          }
          return map;
        }
        case Type.Map_String_Parameter: {
          var map = new Dictionary<string, global::LambdaCube.IR.Parameter> ();
          foreach(var i in (JObject)obj) {
            map.Add( (string)fromJSON(Type.String,i.Key)
                   , (global::LambdaCube.IR.Parameter)fromJSON(Type.Parameter,i.Value));
          }
          return map;
        }

        case Type.ArrayValue: {
          string tag = (string)obj["tag"];
          ArrayValue.Tag tagType;
          if (tag == "VBoolArray") {
            tagType = ArrayValue.Tag.VBoolArray;
            data.VBoolArray tv = new data.VBoolArray();
            tv._0 = (List<bool>)fromJSON(Type.Array_Bool,obj["arg0"]);
            return tv;
          }
          else if (tag == "VIntArray") {
            tagType = ArrayValue.Tag.VIntArray;
            data.VIntArray tv = new data.VIntArray();
            tv._0 = (List<int>)fromJSON(Type.Array_Int32,obj["arg0"]);
            return tv;
          }
          else if (tag == "VWordArray") {
            tagType = ArrayValue.Tag.VWordArray;
            data.VWordArray tv = new data.VWordArray();
            tv._0 = (List<uint>)fromJSON(Type.Array_Word32,obj["arg0"]);
            return tv;
          }
          else if (tag == "VFloatArray") {
            tagType = ArrayValue.Tag.VFloatArray;
            data.VFloatArray tv = new data.VFloatArray();
            tv._0 = (List<float>)fromJSON(Type.Array_Float,obj["arg0"]);
            return tv;
          }
          else throw new Exception("unknown constructor: " + tag);
          ArrayValue o = new ArrayValue();
          o.tag = tagType;
          return o;
        }
        case Type.Value: {
          string tag = (string)obj["tag"];
          Value.Tag tagType;
          if (tag == "VBool") {
            tagType = Value.Tag.VBool;
            data.VBool tv = new data.VBool();
            tv._0 = (bool)fromJSON(Type.Bool,obj["arg0"]);
            return tv;
          }
          else if (tag == "VV2B") {
            tagType = Value.Tag.VV2B;
            data.VV2B tv = new data.VV2B();
            tv._0 = (V2<bool>)fromJSON(Type.V2_Bool,obj["arg0"]);
            return tv;
          }
          else if (tag == "VV3B") {
            tagType = Value.Tag.VV3B;
            data.VV3B tv = new data.VV3B();
            tv._0 = (V3<bool>)fromJSON(Type.V3_Bool,obj["arg0"]);
            return tv;
          }
          else if (tag == "VV4B") {
            tagType = Value.Tag.VV4B;
            data.VV4B tv = new data.VV4B();
            tv._0 = (V4<bool>)fromJSON(Type.V4_Bool,obj["arg0"]);
            return tv;
          }
          else if (tag == "VWord") {
            tagType = Value.Tag.VWord;
            data.VWord tv = new data.VWord();
            tv._0 = (uint)fromJSON(Type.Word32,obj["arg0"]);
            return tv;
          }
          else if (tag == "VV2U") {
            tagType = Value.Tag.VV2U;
            data.VV2U tv = new data.VV2U();
            tv._0 = (V2<uint>)fromJSON(Type.V2_Word,obj["arg0"]);
            return tv;
          }
          else if (tag == "VV3U") {
            tagType = Value.Tag.VV3U;
            data.VV3U tv = new data.VV3U();
            tv._0 = (V3<uint>)fromJSON(Type.V3_Word,obj["arg0"]);
            return tv;
          }
          else if (tag == "VV4U") {
            tagType = Value.Tag.VV4U;
            data.VV4U tv = new data.VV4U();
            tv._0 = (V4<uint>)fromJSON(Type.V4_Word,obj["arg0"]);
            return tv;
          }
          else if (tag == "VInt") {
            tagType = Value.Tag.VInt;
            data.VInt tv = new data.VInt();
            tv._0 = (int)fromJSON(Type.Int32,obj["arg0"]);
            return tv;
          }
          else if (tag == "VV2I") {
            tagType = Value.Tag.VV2I;
            data.VV2I tv = new data.VV2I();
            tv._0 = (V2<int>)fromJSON(Type.V2_Int,obj["arg0"]);
            return tv;
          }
          else if (tag == "VV3I") {
            tagType = Value.Tag.VV3I;
            data.VV3I tv = new data.VV3I();
            tv._0 = (V3<int>)fromJSON(Type.V3_Int,obj["arg0"]);
            return tv;
          }
          else if (tag == "VV4I") {
            tagType = Value.Tag.VV4I;
            data.VV4I tv = new data.VV4I();
            tv._0 = (V4<int>)fromJSON(Type.V4_Int,obj["arg0"]);
            return tv;
          }
          else if (tag == "VFloat") {
            tagType = Value.Tag.VFloat;
            data.VFloat tv = new data.VFloat();
            tv._0 = (float)fromJSON(Type.Float,obj["arg0"]);
            return tv;
          }
          else if (tag == "VV2F") {
            tagType = Value.Tag.VV2F;
            data.VV2F tv = new data.VV2F();
            tv._0 = (V2<float>)fromJSON(Type.V2_Float,obj["arg0"]);
            return tv;
          }
          else if (tag == "VV3F") {
            tagType = Value.Tag.VV3F;
            data.VV3F tv = new data.VV3F();
            tv._0 = (V3<float>)fromJSON(Type.V3_Float,obj["arg0"]);
            return tv;
          }
          else if (tag == "VV4F") {
            tagType = Value.Tag.VV4F;
            data.VV4F tv = new data.VV4F();
            tv._0 = (V4<float>)fromJSON(Type.V4_Float,obj["arg0"]);
            return tv;
          }
          else if (tag == "VM22F") {
            tagType = Value.Tag.VM22F;
            data.VM22F tv = new data.VM22F();
            tv._0 = (V2<V2<float>>)fromJSON(Type.V2_V2_Float,obj["arg0"]);
            return tv;
          }
          else if (tag == "VM23F") {
            tagType = Value.Tag.VM23F;
            data.VM23F tv = new data.VM23F();
            tv._0 = (V3<V2<float>>)fromJSON(Type.V3_V2_Float,obj["arg0"]);
            return tv;
          }
          else if (tag == "VM24F") {
            tagType = Value.Tag.VM24F;
            data.VM24F tv = new data.VM24F();
            tv._0 = (V4<V2<float>>)fromJSON(Type.V4_V2_Float,obj["arg0"]);
            return tv;
          }
          else if (tag == "VM32F") {
            tagType = Value.Tag.VM32F;
            data.VM32F tv = new data.VM32F();
            tv._0 = (V2<V3<float>>)fromJSON(Type.V2_V3_Float,obj["arg0"]);
            return tv;
          }
          else if (tag == "VM33F") {
            tagType = Value.Tag.VM33F;
            data.VM33F tv = new data.VM33F();
            tv._0 = (V3<V3<float>>)fromJSON(Type.V3_V3_Float,obj["arg0"]);
            return tv;
          }
          else if (tag == "VM34F") {
            tagType = Value.Tag.VM34F;
            data.VM34F tv = new data.VM34F();
            tv._0 = (V4<V3<float>>)fromJSON(Type.V4_V3_Float,obj["arg0"]);
            return tv;
          }
          else if (tag == "VM42F") {
            tagType = Value.Tag.VM42F;
            data.VM42F tv = new data.VM42F();
            tv._0 = (V2<V4<float>>)fromJSON(Type.V2_V4_Float,obj["arg0"]);
            return tv;
          }
          else if (tag == "VM43F") {
            tagType = Value.Tag.VM43F;
            data.VM43F tv = new data.VM43F();
            tv._0 = (V3<V4<float>>)fromJSON(Type.V3_V4_Float,obj["arg0"]);
            return tv;
          }
          else if (tag == "VM44F") {
            tagType = Value.Tag.VM44F;
            data.VM44F tv = new data.VM44F();
            tv._0 = (V4<V4<float>>)fromJSON(Type.V4_V4_Float,obj["arg0"]);
            return tv;
          }
          else throw new Exception("unknown constructor: " + tag);
          Value o = new Value();
          o.tag = tagType;
          return o;
        }
        case Type.InputType: {
          string tag = (string)obj["tag"];
          InputType.Tag tagType;
          if (tag == "Bool") {
            tagType = InputType.Tag.Bool;
          }
          else if (tag == "V2B") {
            tagType = InputType.Tag.V2B;
          }
          else if (tag == "V3B") {
            tagType = InputType.Tag.V3B;
          }
          else if (tag == "V4B") {
            tagType = InputType.Tag.V4B;
          }
          else if (tag == "Word") {
            tagType = InputType.Tag.Word;
          }
          else if (tag == "V2U") {
            tagType = InputType.Tag.V2U;
          }
          else if (tag == "V3U") {
            tagType = InputType.Tag.V3U;
          }
          else if (tag == "V4U") {
            tagType = InputType.Tag.V4U;
          }
          else if (tag == "Int") {
            tagType = InputType.Tag.Int;
          }
          else if (tag == "V2I") {
            tagType = InputType.Tag.V2I;
          }
          else if (tag == "V3I") {
            tagType = InputType.Tag.V3I;
          }
          else if (tag == "V4I") {
            tagType = InputType.Tag.V4I;
          }
          else if (tag == "Float") {
            tagType = InputType.Tag.Float;
          }
          else if (tag == "V2F") {
            tagType = InputType.Tag.V2F;
          }
          else if (tag == "V3F") {
            tagType = InputType.Tag.V3F;
          }
          else if (tag == "V4F") {
            tagType = InputType.Tag.V4F;
          }
          else if (tag == "M22F") {
            tagType = InputType.Tag.M22F;
          }
          else if (tag == "M23F") {
            tagType = InputType.Tag.M23F;
          }
          else if (tag == "M24F") {
            tagType = InputType.Tag.M24F;
          }
          else if (tag == "M32F") {
            tagType = InputType.Tag.M32F;
          }
          else if (tag == "M33F") {
            tagType = InputType.Tag.M33F;
          }
          else if (tag == "M34F") {
            tagType = InputType.Tag.M34F;
          }
          else if (tag == "M42F") {
            tagType = InputType.Tag.M42F;
          }
          else if (tag == "M43F") {
            tagType = InputType.Tag.M43F;
          }
          else if (tag == "M44F") {
            tagType = InputType.Tag.M44F;
          }
          else if (tag == "STexture1D") {
            tagType = InputType.Tag.STexture1D;
          }
          else if (tag == "STexture2D") {
            tagType = InputType.Tag.STexture2D;
          }
          else if (tag == "STextureCube") {
            tagType = InputType.Tag.STextureCube;
          }
          else if (tag == "STexture1DArray") {
            tagType = InputType.Tag.STexture1DArray;
          }
          else if (tag == "STexture2DArray") {
            tagType = InputType.Tag.STexture2DArray;
          }
          else if (tag == "STexture2DRect") {
            tagType = InputType.Tag.STexture2DRect;
          }
          else if (tag == "FTexture1D") {
            tagType = InputType.Tag.FTexture1D;
          }
          else if (tag == "FTexture2D") {
            tagType = InputType.Tag.FTexture2D;
          }
          else if (tag == "FTexture3D") {
            tagType = InputType.Tag.FTexture3D;
          }
          else if (tag == "FTextureCube") {
            tagType = InputType.Tag.FTextureCube;
          }
          else if (tag == "FTexture1DArray") {
            tagType = InputType.Tag.FTexture1DArray;
          }
          else if (tag == "FTexture2DArray") {
            tagType = InputType.Tag.FTexture2DArray;
          }
          else if (tag == "FTexture2DMS") {
            tagType = InputType.Tag.FTexture2DMS;
          }
          else if (tag == "FTexture2DMSArray") {
            tagType = InputType.Tag.FTexture2DMSArray;
          }
          else if (tag == "FTextureBuffer") {
            tagType = InputType.Tag.FTextureBuffer;
          }
          else if (tag == "FTexture2DRect") {
            tagType = InputType.Tag.FTexture2DRect;
          }
          else if (tag == "ITexture1D") {
            tagType = InputType.Tag.ITexture1D;
          }
          else if (tag == "ITexture2D") {
            tagType = InputType.Tag.ITexture2D;
          }
          else if (tag == "ITexture3D") {
            tagType = InputType.Tag.ITexture3D;
          }
          else if (tag == "ITextureCube") {
            tagType = InputType.Tag.ITextureCube;
          }
          else if (tag == "ITexture1DArray") {
            tagType = InputType.Tag.ITexture1DArray;
          }
          else if (tag == "ITexture2DArray") {
            tagType = InputType.Tag.ITexture2DArray;
          }
          else if (tag == "ITexture2DMS") {
            tagType = InputType.Tag.ITexture2DMS;
          }
          else if (tag == "ITexture2DMSArray") {
            tagType = InputType.Tag.ITexture2DMSArray;
          }
          else if (tag == "ITextureBuffer") {
            tagType = InputType.Tag.ITextureBuffer;
          }
          else if (tag == "ITexture2DRect") {
            tagType = InputType.Tag.ITexture2DRect;
          }
          else if (tag == "UTexture1D") {
            tagType = InputType.Tag.UTexture1D;
          }
          else if (tag == "UTexture2D") {
            tagType = InputType.Tag.UTexture2D;
          }
          else if (tag == "UTexture3D") {
            tagType = InputType.Tag.UTexture3D;
          }
          else if (tag == "UTextureCube") {
            tagType = InputType.Tag.UTextureCube;
          }
          else if (tag == "UTexture1DArray") {
            tagType = InputType.Tag.UTexture1DArray;
          }
          else if (tag == "UTexture2DArray") {
            tagType = InputType.Tag.UTexture2DArray;
          }
          else if (tag == "UTexture2DMS") {
            tagType = InputType.Tag.UTexture2DMS;
          }
          else if (tag == "UTexture2DMSArray") {
            tagType = InputType.Tag.UTexture2DMSArray;
          }
          else if (tag == "UTextureBuffer") {
            tagType = InputType.Tag.UTextureBuffer;
          }
          else if (tag == "UTexture2DRect") {
            tagType = InputType.Tag.UTexture2DRect;
          }
          else throw new Exception("unknown constructor: " + tag);
          InputType o = new InputType();
          o.tag = tagType;
          return o;
        }
        case Type.PointSpriteCoordOrigin: {
          string tag = (string)obj["tag"];
          PointSpriteCoordOrigin.Tag tagType;
          if (tag == "LowerLeft") {
            tagType = PointSpriteCoordOrigin.Tag.LowerLeft;
          }
          else if (tag == "UpperLeft") {
            tagType = PointSpriteCoordOrigin.Tag.UpperLeft;
          }
          else throw new Exception("unknown constructor: " + tag);
          PointSpriteCoordOrigin o = new PointSpriteCoordOrigin();
          o.tag = tagType;
          return o;
        }
        case Type.PointSize: {
          string tag = (string)obj["tag"];
          PointSize.Tag tagType;
          if (tag == "PointSize") {
            tagType = PointSize.Tag.PointSize;
            data.PointSize tv = new data.PointSize();
            tv._0 = (float)fromJSON(Type.Float,obj["arg0"]);
            return tv;
          }
          else if (tag == "ProgramPointSize") {
            tagType = PointSize.Tag.ProgramPointSize;
          }
          else throw new Exception("unknown constructor: " + tag);
          PointSize o = new PointSize();
          o.tag = tagType;
          return o;
        }
        case Type.PolygonOffset: {
          string tag = (string)obj["tag"];
          PolygonOffset.Tag tagType;
          if (tag == "NoOffset") {
            tagType = PolygonOffset.Tag.NoOffset;
          }
          else if (tag == "Offset") {
            tagType = PolygonOffset.Tag.Offset;
            data.Offset tv = new data.Offset();
            tv._0 = (float)fromJSON(Type.Float,obj["arg0"]);
            tv._1 = (float)fromJSON(Type.Float,obj["arg1"]);
            return tv;
          }
          else throw new Exception("unknown constructor: " + tag);
          PolygonOffset o = new PolygonOffset();
          o.tag = tagType;
          return o;
        }
        case Type.FrontFace: {
          string tag = (string)obj["tag"];
          FrontFace.Tag tagType;
          if (tag == "CCW") {
            tagType = FrontFace.Tag.CCW;
          }
          else if (tag == "CW") {
            tagType = FrontFace.Tag.CW;
          }
          else throw new Exception("unknown constructor: " + tag);
          FrontFace o = new FrontFace();
          o.tag = tagType;
          return o;
        }
        case Type.PolygonMode: {
          string tag = (string)obj["tag"];
          PolygonMode.Tag tagType;
          if (tag == "PolygonPoint") {
            tagType = PolygonMode.Tag.PolygonPoint;
            data.PolygonPoint tv = new data.PolygonPoint();
            tv._0 = (global::LambdaCube.IR.PointSize)fromJSON(Type.PointSize,obj["arg0"]);
            return tv;
          }
          else if (tag == "PolygonLine") {
            tagType = PolygonMode.Tag.PolygonLine;
            data.PolygonLine tv = new data.PolygonLine();
            tv._0 = (float)fromJSON(Type.Float,obj["arg0"]);
            return tv;
          }
          else if (tag == "PolygonFill") {
            tagType = PolygonMode.Tag.PolygonFill;
          }
          else throw new Exception("unknown constructor: " + tag);
          PolygonMode o = new PolygonMode();
          o.tag = tagType;
          return o;
        }
        case Type.ProvokingVertex: {
          string tag = (string)obj["tag"];
          ProvokingVertex.Tag tagType;
          if (tag == "FirstVertex") {
            tagType = ProvokingVertex.Tag.FirstVertex;
          }
          else if (tag == "LastVertex") {
            tagType = ProvokingVertex.Tag.LastVertex;
          }
          else throw new Exception("unknown constructor: " + tag);
          ProvokingVertex o = new ProvokingVertex();
          o.tag = tagType;
          return o;
        }
        case Type.CullMode: {
          string tag = (string)obj["tag"];
          CullMode.Tag tagType;
          if (tag == "CullNone") {
            tagType = CullMode.Tag.CullNone;
          }
          else if (tag == "CullFront") {
            tagType = CullMode.Tag.CullFront;
            data.CullFront tv = new data.CullFront();
            tv._0 = (global::LambdaCube.IR.FrontFace)fromJSON(Type.FrontFace,obj["arg0"]);
            return tv;
          }
          else if (tag == "CullBack") {
            tagType = CullMode.Tag.CullBack;
            data.CullBack tv = new data.CullBack();
            tv._0 = (global::LambdaCube.IR.FrontFace)fromJSON(Type.FrontFace,obj["arg0"]);
            return tv;
          }
          else throw new Exception("unknown constructor: " + tag);
          CullMode o = new CullMode();
          o.tag = tagType;
          return o;
        }
        case Type.ComparisonFunction: {
          string tag = (string)obj["tag"];
          ComparisonFunction.Tag tagType;
          if (tag == "Never") {
            tagType = ComparisonFunction.Tag.Never;
          }
          else if (tag == "Less") {
            tagType = ComparisonFunction.Tag.Less;
          }
          else if (tag == "Equal") {
            tagType = ComparisonFunction.Tag.Equal;
          }
          else if (tag == "Lequal") {
            tagType = ComparisonFunction.Tag.Lequal;
          }
          else if (tag == "Greater") {
            tagType = ComparisonFunction.Tag.Greater;
          }
          else if (tag == "Notequal") {
            tagType = ComparisonFunction.Tag.Notequal;
          }
          else if (tag == "Gequal") {
            tagType = ComparisonFunction.Tag.Gequal;
          }
          else if (tag == "Always") {
            tagType = ComparisonFunction.Tag.Always;
          }
          else throw new Exception("unknown constructor: " + tag);
          ComparisonFunction o = new ComparisonFunction();
          o.tag = tagType;
          return o;
        }
        case Type.StencilOperation: {
          string tag = (string)obj["tag"];
          StencilOperation.Tag tagType;
          if (tag == "OpZero") {
            tagType = StencilOperation.Tag.OpZero;
          }
          else if (tag == "OpKeep") {
            tagType = StencilOperation.Tag.OpKeep;
          }
          else if (tag == "OpReplace") {
            tagType = StencilOperation.Tag.OpReplace;
          }
          else if (tag == "OpIncr") {
            tagType = StencilOperation.Tag.OpIncr;
          }
          else if (tag == "OpIncrWrap") {
            tagType = StencilOperation.Tag.OpIncrWrap;
          }
          else if (tag == "OpDecr") {
            tagType = StencilOperation.Tag.OpDecr;
          }
          else if (tag == "OpDecrWrap") {
            tagType = StencilOperation.Tag.OpDecrWrap;
          }
          else if (tag == "OpInvert") {
            tagType = StencilOperation.Tag.OpInvert;
          }
          else throw new Exception("unknown constructor: " + tag);
          StencilOperation o = new StencilOperation();
          o.tag = tagType;
          return o;
        }
        case Type.BlendEquation: {
          string tag = (string)obj["tag"];
          BlendEquation.Tag tagType;
          if (tag == "FuncAdd") {
            tagType = BlendEquation.Tag.FuncAdd;
          }
          else if (tag == "FuncSubtract") {
            tagType = BlendEquation.Tag.FuncSubtract;
          }
          else if (tag == "FuncReverseSubtract") {
            tagType = BlendEquation.Tag.FuncReverseSubtract;
          }
          else if (tag == "Min") {
            tagType = BlendEquation.Tag.Min;
          }
          else if (tag == "Max") {
            tagType = BlendEquation.Tag.Max;
          }
          else throw new Exception("unknown constructor: " + tag);
          BlendEquation o = new BlendEquation();
          o.tag = tagType;
          return o;
        }
        case Type.BlendingFactor: {
          string tag = (string)obj["tag"];
          BlendingFactor.Tag tagType;
          if (tag == "Zero") {
            tagType = BlendingFactor.Tag.Zero;
          }
          else if (tag == "One") {
            tagType = BlendingFactor.Tag.One;
          }
          else if (tag == "SrcColor") {
            tagType = BlendingFactor.Tag.SrcColor;
          }
          else if (tag == "OneMinusSrcColor") {
            tagType = BlendingFactor.Tag.OneMinusSrcColor;
          }
          else if (tag == "DstColor") {
            tagType = BlendingFactor.Tag.DstColor;
          }
          else if (tag == "OneMinusDstColor") {
            tagType = BlendingFactor.Tag.OneMinusDstColor;
          }
          else if (tag == "SrcAlpha") {
            tagType = BlendingFactor.Tag.SrcAlpha;
          }
          else if (tag == "OneMinusSrcAlpha") {
            tagType = BlendingFactor.Tag.OneMinusSrcAlpha;
          }
          else if (tag == "DstAlpha") {
            tagType = BlendingFactor.Tag.DstAlpha;
          }
          else if (tag == "OneMinusDstAlpha") {
            tagType = BlendingFactor.Tag.OneMinusDstAlpha;
          }
          else if (tag == "ConstantColor") {
            tagType = BlendingFactor.Tag.ConstantColor;
          }
          else if (tag == "OneMinusConstantColor") {
            tagType = BlendingFactor.Tag.OneMinusConstantColor;
          }
          else if (tag == "ConstantAlpha") {
            tagType = BlendingFactor.Tag.ConstantAlpha;
          }
          else if (tag == "OneMinusConstantAlpha") {
            tagType = BlendingFactor.Tag.OneMinusConstantAlpha;
          }
          else if (tag == "SrcAlphaSaturate") {
            tagType = BlendingFactor.Tag.SrcAlphaSaturate;
          }
          else throw new Exception("unknown constructor: " + tag);
          BlendingFactor o = new BlendingFactor();
          o.tag = tagType;
          return o;
        }
        case Type.LogicOperation: {
          string tag = (string)obj["tag"];
          LogicOperation.Tag tagType;
          if (tag == "Clear") {
            tagType = LogicOperation.Tag.Clear;
          }
          else if (tag == "And") {
            tagType = LogicOperation.Tag.And;
          }
          else if (tag == "AndReverse") {
            tagType = LogicOperation.Tag.AndReverse;
          }
          else if (tag == "Copy") {
            tagType = LogicOperation.Tag.Copy;
          }
          else if (tag == "AndInverted") {
            tagType = LogicOperation.Tag.AndInverted;
          }
          else if (tag == "Noop") {
            tagType = LogicOperation.Tag.Noop;
          }
          else if (tag == "Xor") {
            tagType = LogicOperation.Tag.Xor;
          }
          else if (tag == "Or") {
            tagType = LogicOperation.Tag.Or;
          }
          else if (tag == "Nor") {
            tagType = LogicOperation.Tag.Nor;
          }
          else if (tag == "Equiv") {
            tagType = LogicOperation.Tag.Equiv;
          }
          else if (tag == "Invert") {
            tagType = LogicOperation.Tag.Invert;
          }
          else if (tag == "OrReverse") {
            tagType = LogicOperation.Tag.OrReverse;
          }
          else if (tag == "CopyInverted") {
            tagType = LogicOperation.Tag.CopyInverted;
          }
          else if (tag == "OrInverted") {
            tagType = LogicOperation.Tag.OrInverted;
          }
          else if (tag == "Nand") {
            tagType = LogicOperation.Tag.Nand;
          }
          else if (tag == "Set") {
            tagType = LogicOperation.Tag.Set;
          }
          else throw new Exception("unknown constructor: " + tag);
          LogicOperation o = new LogicOperation();
          o.tag = tagType;
          return o;
        }
        case Type.StencilOps: {
          string tag = (string)obj["tag"];
          StencilOps.Tag tagType;
          if (tag == "StencilOps") {
            tagType = StencilOps.Tag.StencilOps;
            data.StencilOps tv = new data.StencilOps();
            tv.frontStencilOp = (global::LambdaCube.IR.StencilOperation)fromJSON(Type.StencilOperation,obj["frontStencilOp"]);
            tv.backStencilOp = (global::LambdaCube.IR.StencilOperation)fromJSON(Type.StencilOperation,obj["backStencilOp"]);
            return tv;
          }
          else throw new Exception("unknown constructor: " + tag);
          StencilOps o = new StencilOps();
          o.tag = tagType;
          return o;
        }
        case Type.StencilTest: {
          string tag = (string)obj["tag"];
          StencilTest.Tag tagType;
          if (tag == "StencilTest") {
            tagType = StencilTest.Tag.StencilTest;
            data.StencilTest tv = new data.StencilTest();
            tv.stencilComparision = (global::LambdaCube.IR.ComparisonFunction)fromJSON(Type.ComparisonFunction,obj["stencilComparision"]);
            tv.stencilReference = (int)fromJSON(Type.Int32,obj["stencilReference"]);
            tv.stencilMask = (uint)fromJSON(Type.Word32,obj["stencilMask"]);
            return tv;
          }
          else throw new Exception("unknown constructor: " + tag);
          StencilTest o = new StencilTest();
          o.tag = tagType;
          return o;
        }
        case Type.StencilTests: {
          string tag = (string)obj["tag"];
          StencilTests.Tag tagType;
          if (tag == "StencilTests") {
            tagType = StencilTests.Tag.StencilTests;
            data.StencilTests tv = new data.StencilTests();
            tv._0 = (global::LambdaCube.IR.StencilTest)fromJSON(Type.StencilTest,obj["arg0"]);
            tv._1 = (global::LambdaCube.IR.StencilTest)fromJSON(Type.StencilTest,obj["arg1"]);
            return tv;
          }
          else throw new Exception("unknown constructor: " + tag);
          StencilTests o = new StencilTests();
          o.tag = tagType;
          return o;
        }
        case Type.FetchPrimitive: {
          string tag = (string)obj["tag"];
          FetchPrimitive.Tag tagType;
          if (tag == "Points") {
            tagType = FetchPrimitive.Tag.Points;
          }
          else if (tag == "Lines") {
            tagType = FetchPrimitive.Tag.Lines;
          }
          else if (tag == "Triangles") {
            tagType = FetchPrimitive.Tag.Triangles;
          }
          else if (tag == "LinesAdjacency") {
            tagType = FetchPrimitive.Tag.LinesAdjacency;
          }
          else if (tag == "TrianglesAdjacency") {
            tagType = FetchPrimitive.Tag.TrianglesAdjacency;
          }
          else throw new Exception("unknown constructor: " + tag);
          FetchPrimitive o = new FetchPrimitive();
          o.tag = tagType;
          return o;
        }
        case Type.OutputPrimitive: {
          string tag = (string)obj["tag"];
          OutputPrimitive.Tag tagType;
          if (tag == "TrianglesOutput") {
            tagType = OutputPrimitive.Tag.TrianglesOutput;
          }
          else if (tag == "LinesOutput") {
            tagType = OutputPrimitive.Tag.LinesOutput;
          }
          else if (tag == "PointsOutput") {
            tagType = OutputPrimitive.Tag.PointsOutput;
          }
          else throw new Exception("unknown constructor: " + tag);
          OutputPrimitive o = new OutputPrimitive();
          o.tag = tagType;
          return o;
        }
        case Type.ColorArity: {
          string tag = (string)obj["tag"];
          ColorArity.Tag tagType;
          if (tag == "Red") {
            tagType = ColorArity.Tag.Red;
          }
          else if (tag == "RG") {
            tagType = ColorArity.Tag.RG;
          }
          else if (tag == "RGB") {
            tagType = ColorArity.Tag.RGB;
          }
          else if (tag == "RGBA") {
            tagType = ColorArity.Tag.RGBA;
          }
          else throw new Exception("unknown constructor: " + tag);
          ColorArity o = new ColorArity();
          o.tag = tagType;
          return o;
        }
        case Type.Blending: {
          string tag = (string)obj["tag"];
          Blending.Tag tagType;
          if (tag == "NoBlending") {
            tagType = Blending.Tag.NoBlending;
          }
          else if (tag == "BlendLogicOp") {
            tagType = Blending.Tag.BlendLogicOp;
            data.BlendLogicOp tv = new data.BlendLogicOp();
            tv._0 = (global::LambdaCube.IR.LogicOperation)fromJSON(Type.LogicOperation,obj["arg0"]);
            return tv;
          }
          else if (tag == "Blend") {
            tagType = Blending.Tag.Blend;
            data.Blend tv = new data.Blend();
            tv.colorEqSrc = (global::LambdaCube.IR.BlendEquation)fromJSON(Type.BlendEquation,obj["colorEqSrc"]);
            tv.alphaEqSrc = (global::LambdaCube.IR.BlendEquation)fromJSON(Type.BlendEquation,obj["alphaEqSrc"]);
            tv.colorFSrc = (global::LambdaCube.IR.BlendingFactor)fromJSON(Type.BlendingFactor,obj["colorFSrc"]);
            tv.colorFDst = (global::LambdaCube.IR.BlendingFactor)fromJSON(Type.BlendingFactor,obj["colorFDst"]);
            tv.alphaFSrc = (global::LambdaCube.IR.BlendingFactor)fromJSON(Type.BlendingFactor,obj["alphaFSrc"]);
            tv.alphaFDst = (global::LambdaCube.IR.BlendingFactor)fromJSON(Type.BlendingFactor,obj["alphaFDst"]);
            tv.color = (V4<float>)fromJSON(Type.V4_Float,obj["color"]);
            return tv;
          }
          else throw new Exception("unknown constructor: " + tag);
          Blending o = new Blending();
          o.tag = tagType;
          return o;
        }
        case Type.RasterContext: {
          string tag = (string)obj["tag"];
          RasterContext.Tag tagType;
          if (tag == "PointCtx") {
            tagType = RasterContext.Tag.PointCtx;
            data.PointCtx tv = new data.PointCtx();
            tv._0 = (global::LambdaCube.IR.PointSize)fromJSON(Type.PointSize,obj["arg0"]);
            tv._1 = (float)fromJSON(Type.Float,obj["arg1"]);
            tv._2 = (global::LambdaCube.IR.PointSpriteCoordOrigin)fromJSON(Type.PointSpriteCoordOrigin,obj["arg2"]);
            return tv;
          }
          else if (tag == "LineCtx") {
            tagType = RasterContext.Tag.LineCtx;
            data.LineCtx tv = new data.LineCtx();
            tv._0 = (float)fromJSON(Type.Float,obj["arg0"]);
            tv._1 = (global::LambdaCube.IR.ProvokingVertex)fromJSON(Type.ProvokingVertex,obj["arg1"]);
            return tv;
          }
          else if (tag == "TriangleCtx") {
            tagType = RasterContext.Tag.TriangleCtx;
            data.TriangleCtx tv = new data.TriangleCtx();
            tv._0 = (global::LambdaCube.IR.CullMode)fromJSON(Type.CullMode,obj["arg0"]);
            tv._1 = (global::LambdaCube.IR.PolygonMode)fromJSON(Type.PolygonMode,obj["arg1"]);
            tv._2 = (global::LambdaCube.IR.PolygonOffset)fromJSON(Type.PolygonOffset,obj["arg2"]);
            tv._3 = (global::LambdaCube.IR.ProvokingVertex)fromJSON(Type.ProvokingVertex,obj["arg3"]);
            return tv;
          }
          else throw new Exception("unknown constructor: " + tag);
          RasterContext o = new RasterContext();
          o.tag = tagType;
          return o;
        }
        case Type.FragmentOperation: {
          string tag = (string)obj["tag"];
          FragmentOperation.Tag tagType;
          if (tag == "DepthOp") {
            tagType = FragmentOperation.Tag.DepthOp;
            data.DepthOp tv = new data.DepthOp();
            tv._0 = (global::LambdaCube.IR.ComparisonFunction)fromJSON(Type.ComparisonFunction,obj["arg0"]);
            tv._1 = (bool)fromJSON(Type.Bool,obj["arg1"]);
            return tv;
          }
          else if (tag == "StencilOp") {
            tagType = FragmentOperation.Tag.StencilOp;
            data.StencilOp tv = new data.StencilOp();
            tv._0 = (global::LambdaCube.IR.StencilTests)fromJSON(Type.StencilTests,obj["arg0"]);
            tv._1 = (global::LambdaCube.IR.StencilOps)fromJSON(Type.StencilOps,obj["arg1"]);
            tv._2 = (global::LambdaCube.IR.StencilOps)fromJSON(Type.StencilOps,obj["arg2"]);
            return tv;
          }
          else if (tag == "ColorOp") {
            tagType = FragmentOperation.Tag.ColorOp;
            data.ColorOp tv = new data.ColorOp();
            tv._0 = (global::LambdaCube.IR.Blending)fromJSON(Type.Blending,obj["arg0"]);
            tv._1 = (global::LambdaCube.IR.Value)fromJSON(Type.Value,obj["arg1"]);
            return tv;
          }
          else throw new Exception("unknown constructor: " + tag);
          FragmentOperation o = new FragmentOperation();
          o.tag = tagType;
          return o;
        }
        case Type.AccumulationContext: {
          string tag = (string)obj["tag"];
          AccumulationContext.Tag tagType;
          if (tag == "AccumulationContext") {
            tagType = AccumulationContext.Tag.AccumulationContext;
            data.AccumulationContext tv = new data.AccumulationContext();
            tv.accViewportName = (Maybe<string>)fromJSON(Type.Maybe_String,obj["accViewportName"]);
            tv.accOperations = (List<global::LambdaCube.IR.FragmentOperation>)fromJSON(Type.List_FragmentOperation,obj["accOperations"]);
            return tv;
          }
          else throw new Exception("unknown constructor: " + tag);
          AccumulationContext o = new AccumulationContext();
          o.tag = tagType;
          return o;
        }
        case Type.TextureDataType: {
          string tag = (string)obj["tag"];
          TextureDataType.Tag tagType;
          if (tag == "FloatT") {
            tagType = TextureDataType.Tag.FloatT;
            data.FloatT tv = new data.FloatT();
            tv._0 = (global::LambdaCube.IR.ColorArity)fromJSON(Type.ColorArity,obj["arg0"]);
            return tv;
          }
          else if (tag == "IntT") {
            tagType = TextureDataType.Tag.IntT;
            data.IntT tv = new data.IntT();
            tv._0 = (global::LambdaCube.IR.ColorArity)fromJSON(Type.ColorArity,obj["arg0"]);
            return tv;
          }
          else if (tag == "WordT") {
            tagType = TextureDataType.Tag.WordT;
            data.WordT tv = new data.WordT();
            tv._0 = (global::LambdaCube.IR.ColorArity)fromJSON(Type.ColorArity,obj["arg0"]);
            return tv;
          }
          else if (tag == "ShadowT") {
            tagType = TextureDataType.Tag.ShadowT;
          }
          else throw new Exception("unknown constructor: " + tag);
          TextureDataType o = new TextureDataType();
          o.tag = tagType;
          return o;
        }
        case Type.TextureType: {
          string tag = (string)obj["tag"];
          TextureType.Tag tagType;
          if (tag == "Texture1D") {
            tagType = TextureType.Tag.Texture1D;
            data.Texture1D tv = new data.Texture1D();
            tv._0 = (global::LambdaCube.IR.TextureDataType)fromJSON(Type.TextureDataType,obj["arg0"]);
            tv._1 = (int)fromJSON(Type.Int,obj["arg1"]);
            return tv;
          }
          else if (tag == "Texture2D") {
            tagType = TextureType.Tag.Texture2D;
            data.Texture2D tv = new data.Texture2D();
            tv._0 = (global::LambdaCube.IR.TextureDataType)fromJSON(Type.TextureDataType,obj["arg0"]);
            tv._1 = (int)fromJSON(Type.Int,obj["arg1"]);
            return tv;
          }
          else if (tag == "Texture3D") {
            tagType = TextureType.Tag.Texture3D;
            data.Texture3D tv = new data.Texture3D();
            tv._0 = (global::LambdaCube.IR.TextureDataType)fromJSON(Type.TextureDataType,obj["arg0"]);
            return tv;
          }
          else if (tag == "TextureCube") {
            tagType = TextureType.Tag.TextureCube;
            data.TextureCube tv = new data.TextureCube();
            tv._0 = (global::LambdaCube.IR.TextureDataType)fromJSON(Type.TextureDataType,obj["arg0"]);
            return tv;
          }
          else if (tag == "TextureRect") {
            tagType = TextureType.Tag.TextureRect;
            data.TextureRect tv = new data.TextureRect();
            tv._0 = (global::LambdaCube.IR.TextureDataType)fromJSON(Type.TextureDataType,obj["arg0"]);
            return tv;
          }
          else if (tag == "Texture2DMS") {
            tagType = TextureType.Tag.Texture2DMS;
            data.Texture2DMS tv = new data.Texture2DMS();
            tv._0 = (global::LambdaCube.IR.TextureDataType)fromJSON(Type.TextureDataType,obj["arg0"]);
            tv._1 = (int)fromJSON(Type.Int,obj["arg1"]);
            tv._2 = (int)fromJSON(Type.Int,obj["arg2"]);
            tv._3 = (bool)fromJSON(Type.Bool,obj["arg3"]);
            return tv;
          }
          else if (tag == "TextureBuffer") {
            tagType = TextureType.Tag.TextureBuffer;
            data.TextureBuffer tv = new data.TextureBuffer();
            tv._0 = (global::LambdaCube.IR.TextureDataType)fromJSON(Type.TextureDataType,obj["arg0"]);
            return tv;
          }
          else throw new Exception("unknown constructor: " + tag);
          TextureType o = new TextureType();
          o.tag = tagType;
          return o;
        }
        case Type.MipMap: {
          string tag = (string)obj["tag"];
          MipMap.Tag tagType;
          if (tag == "Mip") {
            tagType = MipMap.Tag.Mip;
            data.Mip tv = new data.Mip();
            tv._0 = (int)fromJSON(Type.Int,obj["arg0"]);
            tv._1 = (int)fromJSON(Type.Int,obj["arg1"]);
            return tv;
          }
          else if (tag == "NoMip") {
            tagType = MipMap.Tag.NoMip;
          }
          else if (tag == "AutoMip") {
            tagType = MipMap.Tag.AutoMip;
            data.AutoMip tv = new data.AutoMip();
            tv._0 = (int)fromJSON(Type.Int,obj["arg0"]);
            tv._1 = (int)fromJSON(Type.Int,obj["arg1"]);
            return tv;
          }
          else throw new Exception("unknown constructor: " + tag);
          MipMap o = new MipMap();
          o.tag = tagType;
          return o;
        }
        case Type.Filter: {
          string tag = (string)obj["tag"];
          Filter.Tag tagType;
          if (tag == "Nearest") {
            tagType = Filter.Tag.Nearest;
          }
          else if (tag == "Linear") {
            tagType = Filter.Tag.Linear;
          }
          else if (tag == "NearestMipmapNearest") {
            tagType = Filter.Tag.NearestMipmapNearest;
          }
          else if (tag == "NearestMipmapLinear") {
            tagType = Filter.Tag.NearestMipmapLinear;
          }
          else if (tag == "LinearMipmapNearest") {
            tagType = Filter.Tag.LinearMipmapNearest;
          }
          else if (tag == "LinearMipmapLinear") {
            tagType = Filter.Tag.LinearMipmapLinear;
          }
          else throw new Exception("unknown constructor: " + tag);
          Filter o = new Filter();
          o.tag = tagType;
          return o;
        }
        case Type.EdgeMode: {
          string tag = (string)obj["tag"];
          EdgeMode.Tag tagType;
          if (tag == "Repeat") {
            tagType = EdgeMode.Tag.Repeat;
          }
          else if (tag == "MirroredRepeat") {
            tagType = EdgeMode.Tag.MirroredRepeat;
          }
          else if (tag == "ClampToEdge") {
            tagType = EdgeMode.Tag.ClampToEdge;
          }
          else if (tag == "ClampToBorder") {
            tagType = EdgeMode.Tag.ClampToBorder;
          }
          else throw new Exception("unknown constructor: " + tag);
          EdgeMode o = new EdgeMode();
          o.tag = tagType;
          return o;
        }
        case Type.ImageSemantic: {
          string tag = (string)obj["tag"];
          ImageSemantic.Tag tagType;
          if (tag == "Depth") {
            tagType = ImageSemantic.Tag.Depth;
          }
          else if (tag == "Stencil") {
            tagType = ImageSemantic.Tag.Stencil;
          }
          else if (tag == "Color") {
            tagType = ImageSemantic.Tag.Color;
          }
          else throw new Exception("unknown constructor: " + tag);
          ImageSemantic o = new ImageSemantic();
          o.tag = tagType;
          return o;
        }
        case Type.ImageRef: {
          string tag = (string)obj["tag"];
          ImageRef.Tag tagType;
          if (tag == "TextureImage") {
            tagType = ImageRef.Tag.TextureImage;
            data.TextureImage tv = new data.TextureImage();
            tv._0 = (int)fromJSON(Type.Int,obj["arg0"]);
            tv._1 = (int)fromJSON(Type.Int,obj["arg1"]);
            tv._2 = (Maybe<int>)fromJSON(Type.Maybe_Int,obj["arg2"]);
            return tv;
          }
          else if (tag == "Framebuffer") {
            tagType = ImageRef.Tag.Framebuffer;
            data.Framebuffer tv = new data.Framebuffer();
            tv._0 = (global::LambdaCube.IR.ImageSemantic)fromJSON(Type.ImageSemantic,obj["arg0"]);
            return tv;
          }
          else throw new Exception("unknown constructor: " + tag);
          ImageRef o = new ImageRef();
          o.tag = tagType;
          return o;
        }
        case Type.ClearImage: {
          string tag = (string)obj["tag"];
          ClearImage.Tag tagType;
          if (tag == "ClearImage") {
            tagType = ClearImage.Tag.ClearImage;
            data.ClearImage tv = new data.ClearImage();
            tv.imageSemantic = (global::LambdaCube.IR.ImageSemantic)fromJSON(Type.ImageSemantic,obj["imageSemantic"]);
            tv.clearValue = (global::LambdaCube.IR.Value)fromJSON(Type.Value,obj["clearValue"]);
            return tv;
          }
          else throw new Exception("unknown constructor: " + tag);
          ClearImage o = new ClearImage();
          o.tag = tagType;
          return o;
        }
        case Type.Command: {
          string tag = (string)obj["tag"];
          Command.Tag tagType;
          if (tag == "SetRasterContext") {
            tagType = Command.Tag.SetRasterContext;
            data.SetRasterContext tv = new data.SetRasterContext();
            tv._0 = (global::LambdaCube.IR.RasterContext)fromJSON(Type.RasterContext,obj["arg0"]);
            return tv;
          }
          else if (tag == "SetAccumulationContext") {
            tagType = Command.Tag.SetAccumulationContext;
            data.SetAccumulationContext tv = new data.SetAccumulationContext();
            tv._0 = (global::LambdaCube.IR.AccumulationContext)fromJSON(Type.AccumulationContext,obj["arg0"]);
            return tv;
          }
          else if (tag == "SetRenderTarget") {
            tagType = Command.Tag.SetRenderTarget;
            data.SetRenderTarget tv = new data.SetRenderTarget();
            tv._0 = (int)fromJSON(Type.Int,obj["arg0"]);
            return tv;
          }
          else if (tag == "SetProgram") {
            tagType = Command.Tag.SetProgram;
            data.SetProgram tv = new data.SetProgram();
            tv._0 = (int)fromJSON(Type.Int,obj["arg0"]);
            return tv;
          }
          else if (tag == "SetSamplerUniform") {
            tagType = Command.Tag.SetSamplerUniform;
            data.SetSamplerUniform tv = new data.SetSamplerUniform();
            tv._0 = (string)fromJSON(Type.String,obj["arg0"]);
            tv._1 = (int)fromJSON(Type.Int,obj["arg1"]);
            return tv;
          }
          else if (tag == "SetTexture") {
            tagType = Command.Tag.SetTexture;
            data.SetTexture tv = new data.SetTexture();
            tv._0 = (int)fromJSON(Type.Int,obj["arg0"]);
            tv._1 = (int)fromJSON(Type.Int,obj["arg1"]);
            return tv;
          }
          else if (tag == "SetSampler") {
            tagType = Command.Tag.SetSampler;
            data.SetSampler tv = new data.SetSampler();
            tv._0 = (int)fromJSON(Type.Int,obj["arg0"]);
            tv._1 = (Maybe<int>)fromJSON(Type.Maybe_Int,obj["arg1"]);
            return tv;
          }
          else if (tag == "RenderSlot") {
            tagType = Command.Tag.RenderSlot;
            data.RenderSlot tv = new data.RenderSlot();
            tv._0 = (int)fromJSON(Type.Int,obj["arg0"]);
            return tv;
          }
          else if (tag == "RenderStream") {
            tagType = Command.Tag.RenderStream;
            data.RenderStream tv = new data.RenderStream();
            tv._0 = (int)fromJSON(Type.Int,obj["arg0"]);
            return tv;
          }
          else if (tag == "ClearRenderTarget") {
            tagType = Command.Tag.ClearRenderTarget;
            data.ClearRenderTarget tv = new data.ClearRenderTarget();
            tv._0 = (List<global::LambdaCube.IR.ClearImage>)fromJSON(Type.Array_ClearImage,obj["arg0"]);
            return tv;
          }
          else if (tag == "GenerateMipMap") {
            tagType = Command.Tag.GenerateMipMap;
            data.GenerateMipMap tv = new data.GenerateMipMap();
            tv._0 = (int)fromJSON(Type.Int,obj["arg0"]);
            return tv;
          }
          else if (tag == "SaveImage") {
            tagType = Command.Tag.SaveImage;
            data.SaveImage tv = new data.SaveImage();
            tv._0 = (int)fromJSON(Type.Int,obj["arg0"]);
            tv._1 = (global::LambdaCube.IR.ImageRef)fromJSON(Type.ImageRef,obj["arg1"]);
            return tv;
          }
          else if (tag == "LoadImage") {
            tagType = Command.Tag.LoadImage;
            data.LoadImage tv = new data.LoadImage();
            tv._0 = (global::LambdaCube.IR.ImageRef)fromJSON(Type.ImageRef,obj["arg0"]);
            tv._1 = (int)fromJSON(Type.Int,obj["arg1"]);
            return tv;
          }
          else throw new Exception("unknown constructor: " + tag);
          Command o = new Command();
          o.tag = tagType;
          return o;
        }
        case Type.SamplerDescriptor: {
          string tag = (string)obj["tag"];
          SamplerDescriptor.Tag tagType;
          if (tag == "SamplerDescriptor") {
            tagType = SamplerDescriptor.Tag.SamplerDescriptor;
            data.SamplerDescriptor tv = new data.SamplerDescriptor();
            tv.samplerWrapS = (global::LambdaCube.IR.EdgeMode)fromJSON(Type.EdgeMode,obj["samplerWrapS"]);
            tv.samplerWrapT = (Maybe<global::LambdaCube.IR.EdgeMode>)fromJSON(Type.Maybe_EdgeMode,obj["samplerWrapT"]);
            tv.samplerWrapR = (Maybe<global::LambdaCube.IR.EdgeMode>)fromJSON(Type.Maybe_EdgeMode,obj["samplerWrapR"]);
            tv.samplerMinFilter = (global::LambdaCube.IR.Filter)fromJSON(Type.Filter,obj["samplerMinFilter"]);
            tv.samplerMagFilter = (global::LambdaCube.IR.Filter)fromJSON(Type.Filter,obj["samplerMagFilter"]);
            tv.samplerBorderColor = (global::LambdaCube.IR.Value)fromJSON(Type.Value,obj["samplerBorderColor"]);
            tv.samplerMinLod = (Maybe<float>)fromJSON(Type.Maybe_Float,obj["samplerMinLod"]);
            tv.samplerMaxLod = (Maybe<float>)fromJSON(Type.Maybe_Float,obj["samplerMaxLod"]);
            tv.samplerLodBias = (float)fromJSON(Type.Float,obj["samplerLodBias"]);
            tv.samplerCompareFunc = (Maybe<global::LambdaCube.IR.ComparisonFunction>)fromJSON(Type.Maybe_ComparisonFunction,obj["samplerCompareFunc"]);
            return tv;
          }
          else throw new Exception("unknown constructor: " + tag);
          SamplerDescriptor o = new SamplerDescriptor();
          o.tag = tagType;
          return o;
        }
        case Type.TextureDescriptor: {
          string tag = (string)obj["tag"];
          TextureDescriptor.Tag tagType;
          if (tag == "TextureDescriptor") {
            tagType = TextureDescriptor.Tag.TextureDescriptor;
            data.TextureDescriptor tv = new data.TextureDescriptor();
            tv.textureType = (global::LambdaCube.IR.TextureType)fromJSON(Type.TextureType,obj["textureType"]);
            tv.textureSize = (global::LambdaCube.IR.Value)fromJSON(Type.Value,obj["textureSize"]);
            tv.textureSemantic = (global::LambdaCube.IR.ImageSemantic)fromJSON(Type.ImageSemantic,obj["textureSemantic"]);
            tv.textureSampler = (global::LambdaCube.IR.SamplerDescriptor)fromJSON(Type.SamplerDescriptor,obj["textureSampler"]);
            tv.textureBaseLevel = (int)fromJSON(Type.Int,obj["textureBaseLevel"]);
            tv.textureMaxLevel = (int)fromJSON(Type.Int,obj["textureMaxLevel"]);
            return tv;
          }
          else throw new Exception("unknown constructor: " + tag);
          TextureDescriptor o = new TextureDescriptor();
          o.tag = tagType;
          return o;
        }
        case Type.Parameter: {
          string tag = (string)obj["tag"];
          Parameter.Tag tagType;
          if (tag == "Parameter") {
            tagType = Parameter.Tag.Parameter;
            data.Parameter tv = new data.Parameter();
            tv.name = (string)fromJSON(Type.String,obj["name"]);
            tv.ty = (global::LambdaCube.IR.InputType)fromJSON(Type.InputType,obj["ty"]);
            return tv;
          }
          else throw new Exception("unknown constructor: " + tag);
          Parameter o = new Parameter();
          o.tag = tagType;
          return o;
        }
        case Type.Program: {
          string tag = (string)obj["tag"];
          Program.Tag tagType;
          if (tag == "Program") {
            tagType = Program.Tag.Program;
            data.Program tv = new data.Program();
            tv.programUniforms = (Dictionary<string, global::LambdaCube.IR.InputType>)fromJSON(Type.Map_String_InputType,obj["programUniforms"]);
            tv.programStreams = (Dictionary<string, global::LambdaCube.IR.Parameter>)fromJSON(Type.Map_String_Parameter,obj["programStreams"]);
            tv.programInTextures = (Dictionary<string, global::LambdaCube.IR.InputType>)fromJSON(Type.Map_String_InputType,obj["programInTextures"]);
            tv.programOutput = (List<global::LambdaCube.IR.Parameter>)fromJSON(Type.Array_Parameter,obj["programOutput"]);
            tv.vertexShader = (string)fromJSON(Type.String,obj["vertexShader"]);
            tv.geometryShader = (Maybe<string>)fromJSON(Type.Maybe_String,obj["geometryShader"]);
            tv.fragmentShader = (string)fromJSON(Type.String,obj["fragmentShader"]);
            return tv;
          }
          else throw new Exception("unknown constructor: " + tag);
          Program o = new Program();
          o.tag = tagType;
          return o;
        }
        case Type.Slot: {
          string tag = (string)obj["tag"];
          Slot.Tag tagType;
          if (tag == "Slot") {
            tagType = Slot.Tag.Slot;
            data.Slot tv = new data.Slot();
            tv.slotName = (string)fromJSON(Type.String,obj["slotName"]);
            tv.slotStreams = (Dictionary<string, global::LambdaCube.IR.InputType>)fromJSON(Type.Map_String_InputType,obj["slotStreams"]);
            tv.slotUniforms = (Dictionary<string, global::LambdaCube.IR.InputType>)fromJSON(Type.Map_String_InputType,obj["slotUniforms"]);
            tv.slotPrimitive = (global::LambdaCube.IR.FetchPrimitive)fromJSON(Type.FetchPrimitive,obj["slotPrimitive"]);
            tv.slotPrograms = (List<int>)fromJSON(Type.Array_Int,obj["slotPrograms"]);
            return tv;
          }
          else throw new Exception("unknown constructor: " + tag);
          Slot o = new Slot();
          o.tag = tagType;
          return o;
        }
        case Type.StreamData: {
          string tag = (string)obj["tag"];
          StreamData.Tag tagType;
          if (tag == "StreamData") {
            tagType = StreamData.Tag.StreamData;
            data.StreamData tv = new data.StreamData();
            tv.streamData = (Dictionary<string, global::LambdaCube.IR.ArrayValue>)fromJSON(Type.Map_String_ArrayValue,obj["streamData"]);
            tv.streamType = (Dictionary<string, global::LambdaCube.IR.InputType>)fromJSON(Type.Map_String_InputType,obj["streamType"]);
            tv.streamPrimitive = (global::LambdaCube.IR.FetchPrimitive)fromJSON(Type.FetchPrimitive,obj["streamPrimitive"]);
            tv.streamPrograms = (List<int>)fromJSON(Type.Array_Int,obj["streamPrograms"]);
            return tv;
          }
          else throw new Exception("unknown constructor: " + tag);
          StreamData o = new StreamData();
          o.tag = tagType;
          return o;
        }
        case Type.TargetItem: {
          string tag = (string)obj["tag"];
          TargetItem.Tag tagType;
          if (tag == "TargetItem") {
            tagType = TargetItem.Tag.TargetItem;
            data.TargetItem tv = new data.TargetItem();
            tv.targetSemantic = (global::LambdaCube.IR.ImageSemantic)fromJSON(Type.ImageSemantic,obj["targetSemantic"]);
            tv.targetRef = (Maybe<global::LambdaCube.IR.ImageRef>)fromJSON(Type.Maybe_ImageRef,obj["targetRef"]);
            return tv;
          }
          else throw new Exception("unknown constructor: " + tag);
          TargetItem o = new TargetItem();
          o.tag = tagType;
          return o;
        }
        case Type.RenderTarget: {
          string tag = (string)obj["tag"];
          RenderTarget.Tag tagType;
          if (tag == "RenderTarget") {
            tagType = RenderTarget.Tag.RenderTarget;
            data.RenderTarget tv = new data.RenderTarget();
            tv.renderTargets = (List<global::LambdaCube.IR.TargetItem>)fromJSON(Type.Array_TargetItem,obj["renderTargets"]);
            return tv;
          }
          else throw new Exception("unknown constructor: " + tag);
          RenderTarget o = new RenderTarget();
          o.tag = tagType;
          return o;
        }
        case Type.Backend: {
          string tag = (string)obj["tag"];
          Backend.Tag tagType;
          if (tag == "WebGL1") {
            tagType = Backend.Tag.WebGL1;
          }
          else if (tag == "OpenGL33") {
            tagType = Backend.Tag.OpenGL33;
          }
          else throw new Exception("unknown constructor: " + tag);
          Backend o = new Backend();
          o.tag = tagType;
          return o;
        }
        case Type.Pipeline: {
          string tag = (string)obj["tag"];
          Pipeline.Tag tagType;
          if (tag == "Pipeline") {
            tagType = Pipeline.Tag.Pipeline;
            data.Pipeline tv = new data.Pipeline();
            tv.info = (string)fromJSON(Type.String,obj["info"]);
            tv.backend = (global::LambdaCube.IR.Backend)fromJSON(Type.Backend,obj["backend"]);
            tv.textures = (List<global::LambdaCube.IR.TextureDescriptor>)fromJSON(Type.Array_TextureDescriptor,obj["textures"]);
            tv.samplers = (List<global::LambdaCube.IR.SamplerDescriptor>)fromJSON(Type.Array_SamplerDescriptor,obj["samplers"]);
            tv.targets = (List<global::LambdaCube.IR.RenderTarget>)fromJSON(Type.Array_RenderTarget,obj["targets"]);
            tv.programs = (List<global::LambdaCube.IR.Program>)fromJSON(Type.Array_Program,obj["programs"]);
            tv.slots = (List<global::LambdaCube.IR.Slot>)fromJSON(Type.Array_Slot,obj["slots"]);
            tv.streams = (List<global::LambdaCube.IR.StreamData>)fromJSON(Type.Array_StreamData,obj["streams"]);
            tv.commands = (List<global::LambdaCube.IR.Command>)fromJSON(Type.Array_Command,obj["commands"]);
            return tv;
          }
          else throw new Exception("unknown constructor: " + tag);
          Pipeline o = new Pipeline();
          o.tag = tagType;
          return o;
        }
      }
      throw new Exception("unknown type");
      return null;
    }

    JToken toJSON(ArrayValue v) {
      var obj = new JObject();
      switch (v.tag) { 
        case ArrayValue.Tag.VBoolArray:
          obj["tag"] = "VBoolArray";
          {
            var tv = (data.VBoolArray)v;
            obj["arg0"] = toJSON(tv._0);
          }
          break;
        case ArrayValue.Tag.VIntArray:
          obj["tag"] = "VIntArray";
          {
            var tv = (data.VIntArray)v;
            obj["arg0"] = toJSON(tv._0);
          }
          break;
        case ArrayValue.Tag.VWordArray:
          obj["tag"] = "VWordArray";
          {
            var tv = (data.VWordArray)v;
            obj["arg0"] = toJSON(tv._0);
          }
          break;
        case ArrayValue.Tag.VFloatArray:
          obj["tag"] = "VFloatArray";
          {
            var tv = (data.VFloatArray)v;
            obj["arg0"] = toJSON(tv._0);
          }
          break;
      }
      return obj;
    }
    JToken toJSON(Value v) {
      var obj = new JObject();
      switch (v.tag) { 
        case Value.Tag.VBool:
          obj["tag"] = "VBool";
          {
            var tv = (data.VBool)v;
            obj["arg0"] = toJSON(tv._0);
          }
          break;
        case Value.Tag.VV2B:
          obj["tag"] = "VV2B";
          {
            var tv = (data.VV2B)v;
            obj["arg0"] = toJSON(tv._0);
          }
          break;
        case Value.Tag.VV3B:
          obj["tag"] = "VV3B";
          {
            var tv = (data.VV3B)v;
            obj["arg0"] = toJSON(tv._0);
          }
          break;
        case Value.Tag.VV4B:
          obj["tag"] = "VV4B";
          {
            var tv = (data.VV4B)v;
            obj["arg0"] = toJSON(tv._0);
          }
          break;
        case Value.Tag.VWord:
          obj["tag"] = "VWord";
          {
            var tv = (data.VWord)v;
            obj["arg0"] = toJSON(tv._0);
          }
          break;
        case Value.Tag.VV2U:
          obj["tag"] = "VV2U";
          {
            var tv = (data.VV2U)v;
            obj["arg0"] = toJSON(tv._0);
          }
          break;
        case Value.Tag.VV3U:
          obj["tag"] = "VV3U";
          {
            var tv = (data.VV3U)v;
            obj["arg0"] = toJSON(tv._0);
          }
          break;
        case Value.Tag.VV4U:
          obj["tag"] = "VV4U";
          {
            var tv = (data.VV4U)v;
            obj["arg0"] = toJSON(tv._0);
          }
          break;
        case Value.Tag.VInt:
          obj["tag"] = "VInt";
          {
            var tv = (data.VInt)v;
            obj["arg0"] = toJSON(tv._0);
          }
          break;
        case Value.Tag.VV2I:
          obj["tag"] = "VV2I";
          {
            var tv = (data.VV2I)v;
            obj["arg0"] = toJSON(tv._0);
          }
          break;
        case Value.Tag.VV3I:
          obj["tag"] = "VV3I";
          {
            var tv = (data.VV3I)v;
            obj["arg0"] = toJSON(tv._0);
          }
          break;
        case Value.Tag.VV4I:
          obj["tag"] = "VV4I";
          {
            var tv = (data.VV4I)v;
            obj["arg0"] = toJSON(tv._0);
          }
          break;
        case Value.Tag.VFloat:
          obj["tag"] = "VFloat";
          {
            var tv = (data.VFloat)v;
            obj["arg0"] = toJSON(tv._0);
          }
          break;
        case Value.Tag.VV2F:
          obj["tag"] = "VV2F";
          {
            var tv = (data.VV2F)v;
            obj["arg0"] = toJSON(tv._0);
          }
          break;
        case Value.Tag.VV3F:
          obj["tag"] = "VV3F";
          {
            var tv = (data.VV3F)v;
            obj["arg0"] = toJSON(tv._0);
          }
          break;
        case Value.Tag.VV4F:
          obj["tag"] = "VV4F";
          {
            var tv = (data.VV4F)v;
            obj["arg0"] = toJSON(tv._0);
          }
          break;
        case Value.Tag.VM22F:
          obj["tag"] = "VM22F";
          {
            var tv = (data.VM22F)v;
            obj["arg0"] = toJSON(tv._0);
          }
          break;
        case Value.Tag.VM23F:
          obj["tag"] = "VM23F";
          {
            var tv = (data.VM23F)v;
            obj["arg0"] = toJSON(tv._0);
          }
          break;
        case Value.Tag.VM24F:
          obj["tag"] = "VM24F";
          {
            var tv = (data.VM24F)v;
            obj["arg0"] = toJSON(tv._0);
          }
          break;
        case Value.Tag.VM32F:
          obj["tag"] = "VM32F";
          {
            var tv = (data.VM32F)v;
            obj["arg0"] = toJSON(tv._0);
          }
          break;
        case Value.Tag.VM33F:
          obj["tag"] = "VM33F";
          {
            var tv = (data.VM33F)v;
            obj["arg0"] = toJSON(tv._0);
          }
          break;
        case Value.Tag.VM34F:
          obj["tag"] = "VM34F";
          {
            var tv = (data.VM34F)v;
            obj["arg0"] = toJSON(tv._0);
          }
          break;
        case Value.Tag.VM42F:
          obj["tag"] = "VM42F";
          {
            var tv = (data.VM42F)v;
            obj["arg0"] = toJSON(tv._0);
          }
          break;
        case Value.Tag.VM43F:
          obj["tag"] = "VM43F";
          {
            var tv = (data.VM43F)v;
            obj["arg0"] = toJSON(tv._0);
          }
          break;
        case Value.Tag.VM44F:
          obj["tag"] = "VM44F";
          {
            var tv = (data.VM44F)v;
            obj["arg0"] = toJSON(tv._0);
          }
          break;
      }
      return obj;
    }
    JToken toJSON(InputType v) {
      var obj = new JObject();
      switch (v.tag) { 
        case InputType.Tag.Bool:
          obj["tag"] = "Bool";
          break;
        case InputType.Tag.V2B:
          obj["tag"] = "V2B";
          break;
        case InputType.Tag.V3B:
          obj["tag"] = "V3B";
          break;
        case InputType.Tag.V4B:
          obj["tag"] = "V4B";
          break;
        case InputType.Tag.Word:
          obj["tag"] = "Word";
          break;
        case InputType.Tag.V2U:
          obj["tag"] = "V2U";
          break;
        case InputType.Tag.V3U:
          obj["tag"] = "V3U";
          break;
        case InputType.Tag.V4U:
          obj["tag"] = "V4U";
          break;
        case InputType.Tag.Int:
          obj["tag"] = "Int";
          break;
        case InputType.Tag.V2I:
          obj["tag"] = "V2I";
          break;
        case InputType.Tag.V3I:
          obj["tag"] = "V3I";
          break;
        case InputType.Tag.V4I:
          obj["tag"] = "V4I";
          break;
        case InputType.Tag.Float:
          obj["tag"] = "Float";
          break;
        case InputType.Tag.V2F:
          obj["tag"] = "V2F";
          break;
        case InputType.Tag.V3F:
          obj["tag"] = "V3F";
          break;
        case InputType.Tag.V4F:
          obj["tag"] = "V4F";
          break;
        case InputType.Tag.M22F:
          obj["tag"] = "M22F";
          break;
        case InputType.Tag.M23F:
          obj["tag"] = "M23F";
          break;
        case InputType.Tag.M24F:
          obj["tag"] = "M24F";
          break;
        case InputType.Tag.M32F:
          obj["tag"] = "M32F";
          break;
        case InputType.Tag.M33F:
          obj["tag"] = "M33F";
          break;
        case InputType.Tag.M34F:
          obj["tag"] = "M34F";
          break;
        case InputType.Tag.M42F:
          obj["tag"] = "M42F";
          break;
        case InputType.Tag.M43F:
          obj["tag"] = "M43F";
          break;
        case InputType.Tag.M44F:
          obj["tag"] = "M44F";
          break;
        case InputType.Tag.STexture1D:
          obj["tag"] = "STexture1D";
          break;
        case InputType.Tag.STexture2D:
          obj["tag"] = "STexture2D";
          break;
        case InputType.Tag.STextureCube:
          obj["tag"] = "STextureCube";
          break;
        case InputType.Tag.STexture1DArray:
          obj["tag"] = "STexture1DArray";
          break;
        case InputType.Tag.STexture2DArray:
          obj["tag"] = "STexture2DArray";
          break;
        case InputType.Tag.STexture2DRect:
          obj["tag"] = "STexture2DRect";
          break;
        case InputType.Tag.FTexture1D:
          obj["tag"] = "FTexture1D";
          break;
        case InputType.Tag.FTexture2D:
          obj["tag"] = "FTexture2D";
          break;
        case InputType.Tag.FTexture3D:
          obj["tag"] = "FTexture3D";
          break;
        case InputType.Tag.FTextureCube:
          obj["tag"] = "FTextureCube";
          break;
        case InputType.Tag.FTexture1DArray:
          obj["tag"] = "FTexture1DArray";
          break;
        case InputType.Tag.FTexture2DArray:
          obj["tag"] = "FTexture2DArray";
          break;
        case InputType.Tag.FTexture2DMS:
          obj["tag"] = "FTexture2DMS";
          break;
        case InputType.Tag.FTexture2DMSArray:
          obj["tag"] = "FTexture2DMSArray";
          break;
        case InputType.Tag.FTextureBuffer:
          obj["tag"] = "FTextureBuffer";
          break;
        case InputType.Tag.FTexture2DRect:
          obj["tag"] = "FTexture2DRect";
          break;
        case InputType.Tag.ITexture1D:
          obj["tag"] = "ITexture1D";
          break;
        case InputType.Tag.ITexture2D:
          obj["tag"] = "ITexture2D";
          break;
        case InputType.Tag.ITexture3D:
          obj["tag"] = "ITexture3D";
          break;
        case InputType.Tag.ITextureCube:
          obj["tag"] = "ITextureCube";
          break;
        case InputType.Tag.ITexture1DArray:
          obj["tag"] = "ITexture1DArray";
          break;
        case InputType.Tag.ITexture2DArray:
          obj["tag"] = "ITexture2DArray";
          break;
        case InputType.Tag.ITexture2DMS:
          obj["tag"] = "ITexture2DMS";
          break;
        case InputType.Tag.ITexture2DMSArray:
          obj["tag"] = "ITexture2DMSArray";
          break;
        case InputType.Tag.ITextureBuffer:
          obj["tag"] = "ITextureBuffer";
          break;
        case InputType.Tag.ITexture2DRect:
          obj["tag"] = "ITexture2DRect";
          break;
        case InputType.Tag.UTexture1D:
          obj["tag"] = "UTexture1D";
          break;
        case InputType.Tag.UTexture2D:
          obj["tag"] = "UTexture2D";
          break;
        case InputType.Tag.UTexture3D:
          obj["tag"] = "UTexture3D";
          break;
        case InputType.Tag.UTextureCube:
          obj["tag"] = "UTextureCube";
          break;
        case InputType.Tag.UTexture1DArray:
          obj["tag"] = "UTexture1DArray";
          break;
        case InputType.Tag.UTexture2DArray:
          obj["tag"] = "UTexture2DArray";
          break;
        case InputType.Tag.UTexture2DMS:
          obj["tag"] = "UTexture2DMS";
          break;
        case InputType.Tag.UTexture2DMSArray:
          obj["tag"] = "UTexture2DMSArray";
          break;
        case InputType.Tag.UTextureBuffer:
          obj["tag"] = "UTextureBuffer";
          break;
        case InputType.Tag.UTexture2DRect:
          obj["tag"] = "UTexture2DRect";
          break;
      }
      return obj;
    }
    JToken toJSON(PointSpriteCoordOrigin v) {
      var obj = new JObject();
      switch (v.tag) { 
        case PointSpriteCoordOrigin.Tag.LowerLeft:
          obj["tag"] = "LowerLeft";
          break;
        case PointSpriteCoordOrigin.Tag.UpperLeft:
          obj["tag"] = "UpperLeft";
          break;
      }
      return obj;
    }
    JToken toJSON(PointSize v) {
      var obj = new JObject();
      switch (v.tag) { 
        case PointSize.Tag.PointSize:
          obj["tag"] = "PointSize";
          {
            var tv = (data.PointSize)v;
            obj["arg0"] = toJSON(tv._0);
          }
          break;
        case PointSize.Tag.ProgramPointSize:
          obj["tag"] = "ProgramPointSize";
          break;
      }
      return obj;
    }
    JToken toJSON(PolygonOffset v) {
      var obj = new JObject();
      switch (v.tag) { 
        case PolygonOffset.Tag.NoOffset:
          obj["tag"] = "NoOffset";
          break;
        case PolygonOffset.Tag.Offset:
          obj["tag"] = "Offset";
          {
            var tv = (data.Offset)v;
            obj["arg0"] = toJSON(tv._0);
            obj["arg1"] = toJSON(tv._1);
          }
          break;
      }
      return obj;
    }
    JToken toJSON(FrontFace v) {
      var obj = new JObject();
      switch (v.tag) { 
        case FrontFace.Tag.CCW:
          obj["tag"] = "CCW";
          break;
        case FrontFace.Tag.CW:
          obj["tag"] = "CW";
          break;
      }
      return obj;
    }
    JToken toJSON(PolygonMode v) {
      var obj = new JObject();
      switch (v.tag) { 
        case PolygonMode.Tag.PolygonPoint:
          obj["tag"] = "PolygonPoint";
          {
            var tv = (data.PolygonPoint)v;
            obj["arg0"] = toJSON(tv._0);
          }
          break;
        case PolygonMode.Tag.PolygonLine:
          obj["tag"] = "PolygonLine";
          {
            var tv = (data.PolygonLine)v;
            obj["arg0"] = toJSON(tv._0);
          }
          break;
        case PolygonMode.Tag.PolygonFill:
          obj["tag"] = "PolygonFill";
          break;
      }
      return obj;
    }
    JToken toJSON(ProvokingVertex v) {
      var obj = new JObject();
      switch (v.tag) { 
        case ProvokingVertex.Tag.FirstVertex:
          obj["tag"] = "FirstVertex";
          break;
        case ProvokingVertex.Tag.LastVertex:
          obj["tag"] = "LastVertex";
          break;
      }
      return obj;
    }
    JToken toJSON(CullMode v) {
      var obj = new JObject();
      switch (v.tag) { 
        case CullMode.Tag.CullNone:
          obj["tag"] = "CullNone";
          break;
        case CullMode.Tag.CullFront:
          obj["tag"] = "CullFront";
          {
            var tv = (data.CullFront)v;
            obj["arg0"] = toJSON(tv._0);
          }
          break;
        case CullMode.Tag.CullBack:
          obj["tag"] = "CullBack";
          {
            var tv = (data.CullBack)v;
            obj["arg0"] = toJSON(tv._0);
          }
          break;
      }
      return obj;
    }
    JToken toJSON(ComparisonFunction v) {
      var obj = new JObject();
      switch (v.tag) { 
        case ComparisonFunction.Tag.Never:
          obj["tag"] = "Never";
          break;
        case ComparisonFunction.Tag.Less:
          obj["tag"] = "Less";
          break;
        case ComparisonFunction.Tag.Equal:
          obj["tag"] = "Equal";
          break;
        case ComparisonFunction.Tag.Lequal:
          obj["tag"] = "Lequal";
          break;
        case ComparisonFunction.Tag.Greater:
          obj["tag"] = "Greater";
          break;
        case ComparisonFunction.Tag.Notequal:
          obj["tag"] = "Notequal";
          break;
        case ComparisonFunction.Tag.Gequal:
          obj["tag"] = "Gequal";
          break;
        case ComparisonFunction.Tag.Always:
          obj["tag"] = "Always";
          break;
      }
      return obj;
    }
    JToken toJSON(StencilOperation v) {
      var obj = new JObject();
      switch (v.tag) { 
        case StencilOperation.Tag.OpZero:
          obj["tag"] = "OpZero";
          break;
        case StencilOperation.Tag.OpKeep:
          obj["tag"] = "OpKeep";
          break;
        case StencilOperation.Tag.OpReplace:
          obj["tag"] = "OpReplace";
          break;
        case StencilOperation.Tag.OpIncr:
          obj["tag"] = "OpIncr";
          break;
        case StencilOperation.Tag.OpIncrWrap:
          obj["tag"] = "OpIncrWrap";
          break;
        case StencilOperation.Tag.OpDecr:
          obj["tag"] = "OpDecr";
          break;
        case StencilOperation.Tag.OpDecrWrap:
          obj["tag"] = "OpDecrWrap";
          break;
        case StencilOperation.Tag.OpInvert:
          obj["tag"] = "OpInvert";
          break;
      }
      return obj;
    }
    JToken toJSON(BlendEquation v) {
      var obj = new JObject();
      switch (v.tag) { 
        case BlendEquation.Tag.FuncAdd:
          obj["tag"] = "FuncAdd";
          break;
        case BlendEquation.Tag.FuncSubtract:
          obj["tag"] = "FuncSubtract";
          break;
        case BlendEquation.Tag.FuncReverseSubtract:
          obj["tag"] = "FuncReverseSubtract";
          break;
        case BlendEquation.Tag.Min:
          obj["tag"] = "Min";
          break;
        case BlendEquation.Tag.Max:
          obj["tag"] = "Max";
          break;
      }
      return obj;
    }
    JToken toJSON(BlendingFactor v) {
      var obj = new JObject();
      switch (v.tag) { 
        case BlendingFactor.Tag.Zero:
          obj["tag"] = "Zero";
          break;
        case BlendingFactor.Tag.One:
          obj["tag"] = "One";
          break;
        case BlendingFactor.Tag.SrcColor:
          obj["tag"] = "SrcColor";
          break;
        case BlendingFactor.Tag.OneMinusSrcColor:
          obj["tag"] = "OneMinusSrcColor";
          break;
        case BlendingFactor.Tag.DstColor:
          obj["tag"] = "DstColor";
          break;
        case BlendingFactor.Tag.OneMinusDstColor:
          obj["tag"] = "OneMinusDstColor";
          break;
        case BlendingFactor.Tag.SrcAlpha:
          obj["tag"] = "SrcAlpha";
          break;
        case BlendingFactor.Tag.OneMinusSrcAlpha:
          obj["tag"] = "OneMinusSrcAlpha";
          break;
        case BlendingFactor.Tag.DstAlpha:
          obj["tag"] = "DstAlpha";
          break;
        case BlendingFactor.Tag.OneMinusDstAlpha:
          obj["tag"] = "OneMinusDstAlpha";
          break;
        case BlendingFactor.Tag.ConstantColor:
          obj["tag"] = "ConstantColor";
          break;
        case BlendingFactor.Tag.OneMinusConstantColor:
          obj["tag"] = "OneMinusConstantColor";
          break;
        case BlendingFactor.Tag.ConstantAlpha:
          obj["tag"] = "ConstantAlpha";
          break;
        case BlendingFactor.Tag.OneMinusConstantAlpha:
          obj["tag"] = "OneMinusConstantAlpha";
          break;
        case BlendingFactor.Tag.SrcAlphaSaturate:
          obj["tag"] = "SrcAlphaSaturate";
          break;
      }
      return obj;
    }
    JToken toJSON(LogicOperation v) {
      var obj = new JObject();
      switch (v.tag) { 
        case LogicOperation.Tag.Clear:
          obj["tag"] = "Clear";
          break;
        case LogicOperation.Tag.And:
          obj["tag"] = "And";
          break;
        case LogicOperation.Tag.AndReverse:
          obj["tag"] = "AndReverse";
          break;
        case LogicOperation.Tag.Copy:
          obj["tag"] = "Copy";
          break;
        case LogicOperation.Tag.AndInverted:
          obj["tag"] = "AndInverted";
          break;
        case LogicOperation.Tag.Noop:
          obj["tag"] = "Noop";
          break;
        case LogicOperation.Tag.Xor:
          obj["tag"] = "Xor";
          break;
        case LogicOperation.Tag.Or:
          obj["tag"] = "Or";
          break;
        case LogicOperation.Tag.Nor:
          obj["tag"] = "Nor";
          break;
        case LogicOperation.Tag.Equiv:
          obj["tag"] = "Equiv";
          break;
        case LogicOperation.Tag.Invert:
          obj["tag"] = "Invert";
          break;
        case LogicOperation.Tag.OrReverse:
          obj["tag"] = "OrReverse";
          break;
        case LogicOperation.Tag.CopyInverted:
          obj["tag"] = "CopyInverted";
          break;
        case LogicOperation.Tag.OrInverted:
          obj["tag"] = "OrInverted";
          break;
        case LogicOperation.Tag.Nand:
          obj["tag"] = "Nand";
          break;
        case LogicOperation.Tag.Set:
          obj["tag"] = "Set";
          break;
      }
      return obj;
    }
    JToken toJSON(StencilOps v) {
      var obj = new JObject();
      switch (v.tag) { 
        case StencilOps.Tag.StencilOps:
          obj["tag"] = "StencilOps";
          {
            var tv = (data.StencilOps)v;
            obj["frontStencilOp"] = toJSON(tv.frontStencilOp);
            obj["backStencilOp"] = toJSON(tv.backStencilOp);
          }
          break;
      }
      return obj;
    }
    JToken toJSON(StencilTest v) {
      var obj = new JObject();
      switch (v.tag) { 
        case StencilTest.Tag.StencilTest:
          obj["tag"] = "StencilTest";
          {
            var tv = (data.StencilTest)v;
            obj["stencilComparision"] = toJSON(tv.stencilComparision);
            obj["stencilReference"] = toJSON(tv.stencilReference);
            obj["stencilMask"] = toJSON(tv.stencilMask);
          }
          break;
      }
      return obj;
    }
    JToken toJSON(StencilTests v) {
      var obj = new JObject();
      switch (v.tag) { 
        case StencilTests.Tag.StencilTests:
          obj["tag"] = "StencilTests";
          {
            var tv = (data.StencilTests)v;
            obj["arg0"] = toJSON(tv._0);
            obj["arg1"] = toJSON(tv._1);
          }
          break;
      }
      return obj;
    }
    JToken toJSON(FetchPrimitive v) {
      var obj = new JObject();
      switch (v.tag) { 
        case FetchPrimitive.Tag.Points:
          obj["tag"] = "Points";
          break;
        case FetchPrimitive.Tag.Lines:
          obj["tag"] = "Lines";
          break;
        case FetchPrimitive.Tag.Triangles:
          obj["tag"] = "Triangles";
          break;
        case FetchPrimitive.Tag.LinesAdjacency:
          obj["tag"] = "LinesAdjacency";
          break;
        case FetchPrimitive.Tag.TrianglesAdjacency:
          obj["tag"] = "TrianglesAdjacency";
          break;
      }
      return obj;
    }
    JToken toJSON(OutputPrimitive v) {
      var obj = new JObject();
      switch (v.tag) { 
        case OutputPrimitive.Tag.TrianglesOutput:
          obj["tag"] = "TrianglesOutput";
          break;
        case OutputPrimitive.Tag.LinesOutput:
          obj["tag"] = "LinesOutput";
          break;
        case OutputPrimitive.Tag.PointsOutput:
          obj["tag"] = "PointsOutput";
          break;
      }
      return obj;
    }
    JToken toJSON(ColorArity v) {
      var obj = new JObject();
      switch (v.tag) { 
        case ColorArity.Tag.Red:
          obj["tag"] = "Red";
          break;
        case ColorArity.Tag.RG:
          obj["tag"] = "RG";
          break;
        case ColorArity.Tag.RGB:
          obj["tag"] = "RGB";
          break;
        case ColorArity.Tag.RGBA:
          obj["tag"] = "RGBA";
          break;
      }
      return obj;
    }
    JToken toJSON(Blending v) {
      var obj = new JObject();
      switch (v.tag) { 
        case Blending.Tag.NoBlending:
          obj["tag"] = "NoBlending";
          break;
        case Blending.Tag.BlendLogicOp:
          obj["tag"] = "BlendLogicOp";
          {
            var tv = (data.BlendLogicOp)v;
            obj["arg0"] = toJSON(tv._0);
          }
          break;
        case Blending.Tag.Blend:
          obj["tag"] = "Blend";
          {
            var tv = (data.Blend)v;
            obj["colorEqSrc"] = toJSON(tv.colorEqSrc);
            obj["alphaEqSrc"] = toJSON(tv.alphaEqSrc);
            obj["colorFSrc"] = toJSON(tv.colorFSrc);
            obj["colorFDst"] = toJSON(tv.colorFDst);
            obj["alphaFSrc"] = toJSON(tv.alphaFSrc);
            obj["alphaFDst"] = toJSON(tv.alphaFDst);
            obj["color"] = toJSON(tv.color);
          }
          break;
      }
      return obj;
    }
    JToken toJSON(RasterContext v) {
      var obj = new JObject();
      switch (v.tag) { 
        case RasterContext.Tag.PointCtx:
          obj["tag"] = "PointCtx";
          {
            var tv = (data.PointCtx)v;
            obj["arg0"] = toJSON(tv._0);
            obj["arg1"] = toJSON(tv._1);
            obj["arg2"] = toJSON(tv._2);
          }
          break;
        case RasterContext.Tag.LineCtx:
          obj["tag"] = "LineCtx";
          {
            var tv = (data.LineCtx)v;
            obj["arg0"] = toJSON(tv._0);
            obj["arg1"] = toJSON(tv._1);
          }
          break;
        case RasterContext.Tag.TriangleCtx:
          obj["tag"] = "TriangleCtx";
          {
            var tv = (data.TriangleCtx)v;
            obj["arg0"] = toJSON(tv._0);
            obj["arg1"] = toJSON(tv._1);
            obj["arg2"] = toJSON(tv._2);
            obj["arg3"] = toJSON(tv._3);
          }
          break;
      }
      return obj;
    }
    JToken toJSON(FragmentOperation v) {
      var obj = new JObject();
      switch (v.tag) { 
        case FragmentOperation.Tag.DepthOp:
          obj["tag"] = "DepthOp";
          {
            var tv = (data.DepthOp)v;
            obj["arg0"] = toJSON(tv._0);
            obj["arg1"] = toJSON(tv._1);
          }
          break;
        case FragmentOperation.Tag.StencilOp:
          obj["tag"] = "StencilOp";
          {
            var tv = (data.StencilOp)v;
            obj["arg0"] = toJSON(tv._0);
            obj["arg1"] = toJSON(tv._1);
            obj["arg2"] = toJSON(tv._2);
          }
          break;
        case FragmentOperation.Tag.ColorOp:
          obj["tag"] = "ColorOp";
          {
            var tv = (data.ColorOp)v;
            obj["arg0"] = toJSON(tv._0);
            obj["arg1"] = toJSON(tv._1);
          }
          break;
      }
      return obj;
    }
    JToken toJSON(AccumulationContext v) {
      var obj = new JObject();
      switch (v.tag) { 
        case AccumulationContext.Tag.AccumulationContext:
          obj["tag"] = "AccumulationContext";
          {
            var tv = (data.AccumulationContext)v;
            obj["accViewportName"] = toJSON(tv.accViewportName);
            obj["accOperations"] = toJSON(tv.accOperations);
          }
          break;
      }
      return obj;
    }
    JToken toJSON(TextureDataType v) {
      var obj = new JObject();
      switch (v.tag) { 
        case TextureDataType.Tag.FloatT:
          obj["tag"] = "FloatT";
          {
            var tv = (data.FloatT)v;
            obj["arg0"] = toJSON(tv._0);
          }
          break;
        case TextureDataType.Tag.IntT:
          obj["tag"] = "IntT";
          {
            var tv = (data.IntT)v;
            obj["arg0"] = toJSON(tv._0);
          }
          break;
        case TextureDataType.Tag.WordT:
          obj["tag"] = "WordT";
          {
            var tv = (data.WordT)v;
            obj["arg0"] = toJSON(tv._0);
          }
          break;
        case TextureDataType.Tag.ShadowT:
          obj["tag"] = "ShadowT";
          break;
      }
      return obj;
    }
    JToken toJSON(TextureType v) {
      var obj = new JObject();
      switch (v.tag) { 
        case TextureType.Tag.Texture1D:
          obj["tag"] = "Texture1D";
          {
            var tv = (data.Texture1D)v;
            obj["arg0"] = toJSON(tv._0);
            obj["arg1"] = toJSON(tv._1);
          }
          break;
        case TextureType.Tag.Texture2D:
          obj["tag"] = "Texture2D";
          {
            var tv = (data.Texture2D)v;
            obj["arg0"] = toJSON(tv._0);
            obj["arg1"] = toJSON(tv._1);
          }
          break;
        case TextureType.Tag.Texture3D:
          obj["tag"] = "Texture3D";
          {
            var tv = (data.Texture3D)v;
            obj["arg0"] = toJSON(tv._0);
          }
          break;
        case TextureType.Tag.TextureCube:
          obj["tag"] = "TextureCube";
          {
            var tv = (data.TextureCube)v;
            obj["arg0"] = toJSON(tv._0);
          }
          break;
        case TextureType.Tag.TextureRect:
          obj["tag"] = "TextureRect";
          {
            var tv = (data.TextureRect)v;
            obj["arg0"] = toJSON(tv._0);
          }
          break;
        case TextureType.Tag.Texture2DMS:
          obj["tag"] = "Texture2DMS";
          {
            var tv = (data.Texture2DMS)v;
            obj["arg0"] = toJSON(tv._0);
            obj["arg1"] = toJSON(tv._1);
            obj["arg2"] = toJSON(tv._2);
            obj["arg3"] = toJSON(tv._3);
          }
          break;
        case TextureType.Tag.TextureBuffer:
          obj["tag"] = "TextureBuffer";
          {
            var tv = (data.TextureBuffer)v;
            obj["arg0"] = toJSON(tv._0);
          }
          break;
      }
      return obj;
    }
    JToken toJSON(MipMap v) {
      var obj = new JObject();
      switch (v.tag) { 
        case MipMap.Tag.Mip:
          obj["tag"] = "Mip";
          {
            var tv = (data.Mip)v;
            obj["arg0"] = toJSON(tv._0);
            obj["arg1"] = toJSON(tv._1);
          }
          break;
        case MipMap.Tag.NoMip:
          obj["tag"] = "NoMip";
          break;
        case MipMap.Tag.AutoMip:
          obj["tag"] = "AutoMip";
          {
            var tv = (data.AutoMip)v;
            obj["arg0"] = toJSON(tv._0);
            obj["arg1"] = toJSON(tv._1);
          }
          break;
      }
      return obj;
    }
    JToken toJSON(Filter v) {
      var obj = new JObject();
      switch (v.tag) { 
        case Filter.Tag.Nearest:
          obj["tag"] = "Nearest";
          break;
        case Filter.Tag.Linear:
          obj["tag"] = "Linear";
          break;
        case Filter.Tag.NearestMipmapNearest:
          obj["tag"] = "NearestMipmapNearest";
          break;
        case Filter.Tag.NearestMipmapLinear:
          obj["tag"] = "NearestMipmapLinear";
          break;
        case Filter.Tag.LinearMipmapNearest:
          obj["tag"] = "LinearMipmapNearest";
          break;
        case Filter.Tag.LinearMipmapLinear:
          obj["tag"] = "LinearMipmapLinear";
          break;
      }
      return obj;
    }
    JToken toJSON(EdgeMode v) {
      var obj = new JObject();
      switch (v.tag) { 
        case EdgeMode.Tag.Repeat:
          obj["tag"] = "Repeat";
          break;
        case EdgeMode.Tag.MirroredRepeat:
          obj["tag"] = "MirroredRepeat";
          break;
        case EdgeMode.Tag.ClampToEdge:
          obj["tag"] = "ClampToEdge";
          break;
        case EdgeMode.Tag.ClampToBorder:
          obj["tag"] = "ClampToBorder";
          break;
      }
      return obj;
    }
    JToken toJSON(ImageSemantic v) {
      var obj = new JObject();
      switch (v.tag) { 
        case ImageSemantic.Tag.Depth:
          obj["tag"] = "Depth";
          break;
        case ImageSemantic.Tag.Stencil:
          obj["tag"] = "Stencil";
          break;
        case ImageSemantic.Tag.Color:
          obj["tag"] = "Color";
          break;
      }
      return obj;
    }
    JToken toJSON(ImageRef v) {
      var obj = new JObject();
      switch (v.tag) { 
        case ImageRef.Tag.TextureImage:
          obj["tag"] = "TextureImage";
          {
            var tv = (data.TextureImage)v;
            obj["arg0"] = toJSON(tv._0);
            obj["arg1"] = toJSON(tv._1);
            obj["arg2"] = toJSON(tv._2);
          }
          break;
        case ImageRef.Tag.Framebuffer:
          obj["tag"] = "Framebuffer";
          {
            var tv = (data.Framebuffer)v;
            obj["arg0"] = toJSON(tv._0);
          }
          break;
      }
      return obj;
    }
    JToken toJSON(ClearImage v) {
      var obj = new JObject();
      switch (v.tag) { 
        case ClearImage.Tag.ClearImage:
          obj["tag"] = "ClearImage";
          {
            var tv = (data.ClearImage)v;
            obj["imageSemantic"] = toJSON(tv.imageSemantic);
            obj["clearValue"] = toJSON(tv.clearValue);
          }
          break;
      }
      return obj;
    }
    JToken toJSON(Command v) {
      var obj = new JObject();
      switch (v.tag) { 
        case Command.Tag.SetRasterContext:
          obj["tag"] = "SetRasterContext";
          {
            var tv = (data.SetRasterContext)v;
            obj["arg0"] = toJSON(tv._0);
          }
          break;
        case Command.Tag.SetAccumulationContext:
          obj["tag"] = "SetAccumulationContext";
          {
            var tv = (data.SetAccumulationContext)v;
            obj["arg0"] = toJSON(tv._0);
          }
          break;
        case Command.Tag.SetRenderTarget:
          obj["tag"] = "SetRenderTarget";
          {
            var tv = (data.SetRenderTarget)v;
            obj["arg0"] = toJSON(tv._0);
          }
          break;
        case Command.Tag.SetProgram:
          obj["tag"] = "SetProgram";
          {
            var tv = (data.SetProgram)v;
            obj["arg0"] = toJSON(tv._0);
          }
          break;
        case Command.Tag.SetSamplerUniform:
          obj["tag"] = "SetSamplerUniform";
          {
            var tv = (data.SetSamplerUniform)v;
            obj["arg0"] = toJSON(tv._0);
            obj["arg1"] = toJSON(tv._1);
          }
          break;
        case Command.Tag.SetTexture:
          obj["tag"] = "SetTexture";
          {
            var tv = (data.SetTexture)v;
            obj["arg0"] = toJSON(tv._0);
            obj["arg1"] = toJSON(tv._1);
          }
          break;
        case Command.Tag.SetSampler:
          obj["tag"] = "SetSampler";
          {
            var tv = (data.SetSampler)v;
            obj["arg0"] = toJSON(tv._0);
            obj["arg1"] = toJSON(tv._1);
          }
          break;
        case Command.Tag.RenderSlot:
          obj["tag"] = "RenderSlot";
          {
            var tv = (data.RenderSlot)v;
            obj["arg0"] = toJSON(tv._0);
          }
          break;
        case Command.Tag.RenderStream:
          obj["tag"] = "RenderStream";
          {
            var tv = (data.RenderStream)v;
            obj["arg0"] = toJSON(tv._0);
          }
          break;
        case Command.Tag.ClearRenderTarget:
          obj["tag"] = "ClearRenderTarget";
          {
            var tv = (data.ClearRenderTarget)v;
            obj["arg0"] = toJSON(tv._0);
          }
          break;
        case Command.Tag.GenerateMipMap:
          obj["tag"] = "GenerateMipMap";
          {
            var tv = (data.GenerateMipMap)v;
            obj["arg0"] = toJSON(tv._0);
          }
          break;
        case Command.Tag.SaveImage:
          obj["tag"] = "SaveImage";
          {
            var tv = (data.SaveImage)v;
            obj["arg0"] = toJSON(tv._0);
            obj["arg1"] = toJSON(tv._1);
          }
          break;
        case Command.Tag.LoadImage:
          obj["tag"] = "LoadImage";
          {
            var tv = (data.LoadImage)v;
            obj["arg0"] = toJSON(tv._0);
            obj["arg1"] = toJSON(tv._1);
          }
          break;
      }
      return obj;
    }
    JToken toJSON(SamplerDescriptor v) {
      var obj = new JObject();
      switch (v.tag) { 
        case SamplerDescriptor.Tag.SamplerDescriptor:
          obj["tag"] = "SamplerDescriptor";
          {
            var tv = (data.SamplerDescriptor)v;
            obj["samplerWrapS"] = toJSON(tv.samplerWrapS);
            obj["samplerWrapT"] = toJSON(tv.samplerWrapT);
            obj["samplerWrapR"] = toJSON(tv.samplerWrapR);
            obj["samplerMinFilter"] = toJSON(tv.samplerMinFilter);
            obj["samplerMagFilter"] = toJSON(tv.samplerMagFilter);
            obj["samplerBorderColor"] = toJSON(tv.samplerBorderColor);
            obj["samplerMinLod"] = toJSON(tv.samplerMinLod);
            obj["samplerMaxLod"] = toJSON(tv.samplerMaxLod);
            obj["samplerLodBias"] = toJSON(tv.samplerLodBias);
            obj["samplerCompareFunc"] = toJSON(tv.samplerCompareFunc);
          }
          break;
      }
      return obj;
    }
    JToken toJSON(TextureDescriptor v) {
      var obj = new JObject();
      switch (v.tag) { 
        case TextureDescriptor.Tag.TextureDescriptor:
          obj["tag"] = "TextureDescriptor";
          {
            var tv = (data.TextureDescriptor)v;
            obj["textureType"] = toJSON(tv.textureType);
            obj["textureSize"] = toJSON(tv.textureSize);
            obj["textureSemantic"] = toJSON(tv.textureSemantic);
            obj["textureSampler"] = toJSON(tv.textureSampler);
            obj["textureBaseLevel"] = toJSON(tv.textureBaseLevel);
            obj["textureMaxLevel"] = toJSON(tv.textureMaxLevel);
          }
          break;
      }
      return obj;
    }
    JToken toJSON(Parameter v) {
      var obj = new JObject();
      switch (v.tag) { 
        case Parameter.Tag.Parameter:
          obj["tag"] = "Parameter";
          {
            var tv = (data.Parameter)v;
            obj["name"] = toJSON(tv.name);
            obj["ty"] = toJSON(tv.ty);
          }
          break;
      }
      return obj;
    }
    JToken toJSON(Program v) {
      var obj = new JObject();
      switch (v.tag) { 
        case Program.Tag.Program:
          obj["tag"] = "Program";
          {
            var tv = (data.Program)v;
            obj["programUniforms"] = toJSON(tv.programUniforms);
            obj["programStreams"] = toJSON(tv.programStreams);
            obj["programInTextures"] = toJSON(tv.programInTextures);
            obj["programOutput"] = toJSON(tv.programOutput);
            obj["vertexShader"] = toJSON(tv.vertexShader);
            obj["geometryShader"] = toJSON(tv.geometryShader);
            obj["fragmentShader"] = toJSON(tv.fragmentShader);
          }
          break;
      }
      return obj;
    }
    JToken toJSON(Slot v) {
      var obj = new JObject();
      switch (v.tag) { 
        case Slot.Tag.Slot:
          obj["tag"] = "Slot";
          {
            var tv = (data.Slot)v;
            obj["slotName"] = toJSON(tv.slotName);
            obj["slotStreams"] = toJSON(tv.slotStreams);
            obj["slotUniforms"] = toJSON(tv.slotUniforms);
            obj["slotPrimitive"] = toJSON(tv.slotPrimitive);
            obj["slotPrograms"] = toJSON(tv.slotPrograms);
          }
          break;
      }
      return obj;
    }
    JToken toJSON(StreamData v) {
      var obj = new JObject();
      switch (v.tag) { 
        case StreamData.Tag.StreamData:
          obj["tag"] = "StreamData";
          {
            var tv = (data.StreamData)v;
            obj["streamData"] = toJSON(tv.streamData);
            obj["streamType"] = toJSON(tv.streamType);
            obj["streamPrimitive"] = toJSON(tv.streamPrimitive);
            obj["streamPrograms"] = toJSON(tv.streamPrograms);
          }
          break;
      }
      return obj;
    }
    JToken toJSON(TargetItem v) {
      var obj = new JObject();
      switch (v.tag) { 
        case TargetItem.Tag.TargetItem:
          obj["tag"] = "TargetItem";
          {
            var tv = (data.TargetItem)v;
            obj["targetSemantic"] = toJSON(tv.targetSemantic);
            obj["targetRef"] = toJSON(tv.targetRef);
          }
          break;
      }
      return obj;
    }
    JToken toJSON(RenderTarget v) {
      var obj = new JObject();
      switch (v.tag) { 
        case RenderTarget.Tag.RenderTarget:
          obj["tag"] = "RenderTarget";
          {
            var tv = (data.RenderTarget)v;
            obj["renderTargets"] = toJSON(tv.renderTargets);
          }
          break;
      }
      return obj;
    }
    JToken toJSON(Backend v) {
      var obj = new JObject();
      switch (v.tag) { 
        case Backend.Tag.WebGL1:
          obj["tag"] = "WebGL1";
          break;
        case Backend.Tag.OpenGL33:
          obj["tag"] = "OpenGL33";
          break;
      }
      return obj;
    }
    JToken toJSON(Pipeline v) {
      var obj = new JObject();
      switch (v.tag) { 
        case Pipeline.Tag.Pipeline:
          obj["tag"] = "Pipeline";
          {
            var tv = (data.Pipeline)v;
            obj["info"] = toJSON(tv.info);
            obj["backend"] = toJSON(tv.backend);
            obj["textures"] = toJSON(tv.textures);
            obj["samplers"] = toJSON(tv.samplers);
            obj["targets"] = toJSON(tv.targets);
            obj["programs"] = toJSON(tv.programs);
            obj["slots"] = toJSON(tv.slots);
            obj["streams"] = toJSON(tv.streams);
            obj["commands"] = toJSON(tv.commands);
          }
          break;
      }
      return obj;
    }

    JToken toJSON(int v) { return new JValue(v); }
    JToken toJSON(uint v) { return new JValue(v); }
    JToken toJSON(float v) { return new JValue(v); }
    JToken toJSON(bool v) { return new JValue(v); }
    JToken toJSON(string v) { return new JValue(v); }
    JToken toJSON(V2<int> v) {
      var obj = new JObject();
      obj["x"] = toJSON(v.x);
      obj["y"] = toJSON(v.y);
      return obj;
    }
    JToken toJSON(V2<uint> v) {
      var obj = new JObject();
      obj["x"] = toJSON(v.x);
      obj["y"] = toJSON(v.y);
      return obj;
    }
    JToken toJSON(V2<float> v) {
      var obj = new JObject();
      obj["x"] = toJSON(v.x);
      obj["y"] = toJSON(v.y);
      return obj;
    }
    JToken toJSON(V2<bool> v) {
      var obj = new JObject();
      obj["x"] = toJSON(v.x);
      obj["y"] = toJSON(v.y);
      return obj;
    }
    JToken toJSON(V2<V2<float>> v) {
      var obj = new JObject();
      obj["x"] = toJSON(v.x);
      obj["y"] = toJSON(v.y);
      return obj;
    }
    JToken toJSON(V2<V3<float>> v) {
      var obj = new JObject();
      obj["x"] = toJSON(v.x);
      obj["y"] = toJSON(v.y);
      return obj;
    }
    JToken toJSON(V2<V4<float>> v) {
      var obj = new JObject();
      obj["x"] = toJSON(v.x);
      obj["y"] = toJSON(v.y);
      return obj;
    }
    JToken toJSON(V3<int> v) {
      var obj = new JObject();
      obj["x"] = toJSON(v.x);
      obj["y"] = toJSON(v.y);
      obj["z"] = toJSON(v.z);
      return obj;
    }
    JToken toJSON(V3<uint> v) {
      var obj = new JObject();
      obj["x"] = toJSON(v.x);
      obj["y"] = toJSON(v.y);
      obj["z"] = toJSON(v.z);
      return obj;
    }
    JToken toJSON(V3<float> v) {
      var obj = new JObject();
      obj["x"] = toJSON(v.x);
      obj["y"] = toJSON(v.y);
      obj["z"] = toJSON(v.z);
      return obj;
    }
    JToken toJSON(V3<bool> v) {
      var obj = new JObject();
      obj["x"] = toJSON(v.x);
      obj["y"] = toJSON(v.y);
      obj["z"] = toJSON(v.z);
      return obj;
    }
    JToken toJSON(V3<V2<float>> v) {
      var obj = new JObject();
      obj["x"] = toJSON(v.x);
      obj["y"] = toJSON(v.y);
      obj["z"] = toJSON(v.z);
      return obj;
    }
    JToken toJSON(V3<V3<float>> v) {
      var obj = new JObject();
      obj["x"] = toJSON(v.x);
      obj["y"] = toJSON(v.y);
      obj["z"] = toJSON(v.z);
      return obj;
    }
    JToken toJSON(V3<V4<float>> v) {
      var obj = new JObject();
      obj["x"] = toJSON(v.x);
      obj["y"] = toJSON(v.y);
      obj["z"] = toJSON(v.z);
      return obj;
    }
    JToken toJSON(V4<int> v) {
      var obj = new JObject();
      obj["x"] = toJSON(v.x);
      obj["y"] = toJSON(v.y);
      obj["z"] = toJSON(v.z);
      obj["w"] = toJSON(v.w);
      return obj;
    }
    JToken toJSON(V4<uint> v) {
      var obj = new JObject();
      obj["x"] = toJSON(v.x);
      obj["y"] = toJSON(v.y);
      obj["z"] = toJSON(v.z);
      obj["w"] = toJSON(v.w);
      return obj;
    }
    JToken toJSON(V4<float> v) {
      var obj = new JObject();
      obj["x"] = toJSON(v.x);
      obj["y"] = toJSON(v.y);
      obj["z"] = toJSON(v.z);
      obj["w"] = toJSON(v.w);
      return obj;
    }
    JToken toJSON(V4<bool> v) {
      var obj = new JObject();
      obj["x"] = toJSON(v.x);
      obj["y"] = toJSON(v.y);
      obj["z"] = toJSON(v.z);
      obj["w"] = toJSON(v.w);
      return obj;
    }
    JToken toJSON(V4<V2<float>> v) {
      var obj = new JObject();
      obj["x"] = toJSON(v.x);
      obj["y"] = toJSON(v.y);
      obj["z"] = toJSON(v.z);
      obj["w"] = toJSON(v.w);
      return obj;
    }
    JToken toJSON(V4<V3<float>> v) {
      var obj = new JObject();
      obj["x"] = toJSON(v.x);
      obj["y"] = toJSON(v.y);
      obj["z"] = toJSON(v.z);
      obj["w"] = toJSON(v.w);
      return obj;
    }
    JToken toJSON(V4<V4<float>> v) {
      var obj = new JObject();
      obj["x"] = toJSON(v.x);
      obj["y"] = toJSON(v.y);
      obj["z"] = toJSON(v.z);
      obj["w"] = toJSON(v.w);
      return obj;
    }
    JToken toJSON(List<int> v) {
      var obj = new JArray();
      foreach (var i in v) {
        obj.Add(toJSON(i));
      }
      return obj;
    }
    JToken toJSON(List<uint> v) {
      var obj = new JArray();
      foreach (var i in v) {
        obj.Add(toJSON(i));
      }
      return obj;
    }
    JToken toJSON(List<float> v) {
      var obj = new JArray();
      foreach (var i in v) {
        obj.Add(toJSON(i));
      }
      return obj;
    }
    JToken toJSON(List<bool> v) {
      var obj = new JArray();
      foreach (var i in v) {
        obj.Add(toJSON(i));
      }
      return obj;
    }
    JToken toJSON(List<global::LambdaCube.IR.ClearImage> v) {
      var obj = new JArray();
      foreach (var i in v) {
        obj.Add(toJSON(i));
      }
      return obj;
    }
    JToken toJSON(List<global::LambdaCube.IR.Command> v) {
      var obj = new JArray();
      foreach (var i in v) {
        obj.Add(toJSON(i));
      }
      return obj;
    }
    JToken toJSON(List<global::LambdaCube.IR.Parameter> v) {
      var obj = new JArray();
      foreach (var i in v) {
        obj.Add(toJSON(i));
      }
      return obj;
    }
    JToken toJSON(List<global::LambdaCube.IR.Program> v) {
      var obj = new JArray();
      foreach (var i in v) {
        obj.Add(toJSON(i));
      }
      return obj;
    }
    JToken toJSON(List<global::LambdaCube.IR.RenderTarget> v) {
      var obj = new JArray();
      foreach (var i in v) {
        obj.Add(toJSON(i));
      }
      return obj;
    }
    JToken toJSON(List<global::LambdaCube.IR.SamplerDescriptor> v) {
      var obj = new JArray();
      foreach (var i in v) {
        obj.Add(toJSON(i));
      }
      return obj;
    }
    JToken toJSON(List<global::LambdaCube.IR.Slot> v) {
      var obj = new JArray();
      foreach (var i in v) {
        obj.Add(toJSON(i));
      }
      return obj;
    }
    JToken toJSON(List<global::LambdaCube.IR.StreamData> v) {
      var obj = new JArray();
      foreach (var i in v) {
        obj.Add(toJSON(i));
      }
      return obj;
    }
    JToken toJSON(List<global::LambdaCube.IR.TargetItem> v) {
      var obj = new JArray();
      foreach (var i in v) {
        obj.Add(toJSON(i));
      }
      return obj;
    }
    JToken toJSON(List<global::LambdaCube.IR.TextureDescriptor> v) {
      var obj = new JArray();
      foreach (var i in v) {
        obj.Add(toJSON(i));
      }
      return obj;
    }
    JToken toJSON(List<global::LambdaCube.IR.FragmentOperation> v) {
      var obj = new JArray();
      foreach (var i in v) {
        obj.Add(toJSON(i));
      }
      return obj;
    }
    JToken toJSON(Maybe<int> v) {
      if (v.valid) {
        return toJSON(v.data);
      }
      return new JValue((string)null);
    }
    JToken toJSON(Maybe<float> v) {
      if (v.valid) {
        return toJSON(v.data);
      }
      return new JValue((string)null);
    }
    JToken toJSON(Maybe<string> v) {
      if (v.valid) {
        return toJSON(v.data);
      }
      return new JValue((string)null);
    }
    JToken toJSON(Maybe<global::LambdaCube.IR.ComparisonFunction> v) {
      if (v.valid) {
        return toJSON(v.data);
      }
      return new JValue((string)null);
    }
    JToken toJSON(Maybe<global::LambdaCube.IR.EdgeMode> v) {
      if (v.valid) {
        return toJSON(v.data);
      }
      return new JValue((string)null);
    }
    JToken toJSON(Maybe<global::LambdaCube.IR.ImageRef> v) {
      if (v.valid) {
        return toJSON(v.data);
      }
      return new JValue((string)null);
    }
    JToken toJSON(Dictionary<string, global::LambdaCube.IR.ArrayValue> v) {
      var obj = new JObject();
      foreach (var i in v) {
        obj[i.Key] = toJSON(i.Value);
      }
      return obj;
    }
    JToken toJSON(Dictionary<string, global::LambdaCube.IR.InputType> v) {
      var obj = new JObject();
      foreach (var i in v) {
        obj[i.Key] = toJSON(i.Value);
      }
      return obj;
    }
    JToken toJSON(Dictionary<string, global::LambdaCube.IR.Parameter> v) {
      var obj = new JObject();
      foreach (var i in v) {
        obj[i.Key] = toJSON(i.Value);
      }
      return obj;
    }
  }
}