<?xml version="1.0" encoding="us-ascii"?>
<ErrorDocumentation xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <ErrorName>CS0266</ErrorName>
  <Examples>
    <string>// cs0266: Cannot implicitly convert type `long' to `int'. An explicit conversion exists (are you missing a cast?)
// Line: 7

public class Test
{
	const uint a = 2147483648;
	const int b = -a;
}</string>
    <string>// cs0266: Cannot implicitly convert type `int' to `X.E'. An explicit conversion exists (are you missing a cast?)
// Line : 9

class X {
        enum E { }
        
        static void Main ()
        {
                const E e = 1 - 1;
        }
}



</string>
    <string>// CS0266: Cannot implicitly convert type `int' to `char'. An explicit conversion exists (are you missing a cast?)
// Line: 12

class X
{
	public static void Main ()
	{
		char x = 'A';
		char b = +x;
	}
}
</string>
    <string>// CS0266: Cannot implicitly convert type `int' to `sbyte'. An explicit conversion exists (are you missing a cast?)
// Line: 33

class A3
{
	public static implicit operator sbyte (A3 mask)
	{
		return 1;
	}

	public static implicit operator uint (A3 mask)
	{
		return 6;
	}
	
	public static implicit operator long (A3 mask)
	{
		return 7;
	}

	public static implicit operator ulong (A3 mask)
	{
		return 8;
	}
}


public class C
{
	public static int Main ()
	{
		A3 a3 = null;
		sbyte sa3 = -a3;
	}
}
</string>
    <string>// CS0266: Cannot implicitly convert type `System.IntPtr' to `byte*'. An explicit conversion exists (are you missing a cast?)
// Line: 23
// Compiler options: -unsafe

using System;

public class Pixbuf {
        static void Main (string [] args)
	{
		Bug ();
	}

	public IntPtr Pixels {
		get {
			return IntPtr.Zero;
		}
	}
	public static unsafe void Bug ()
	{
		Pixbuf pixbuf = null;
		//should be:
		//byte *pix = (byte *)pixbuf.Pixels;
		byte *pix = pixbuf.Pixels;
	}
}



</string>
    <string>// CS0266: Cannot implicitly convert type `object' to `System.Collections.Hashtable'. An explicit conversion exists (are you missing a cast?)
// Line: 17

// This case actually tests that the compiler doesn't crash after reporting the error

using System.Collections;

class X {
        static void Main (string [] install)
        {
                ArrayList order = new ArrayList ();
                Hashtable states = new Hashtable ();

                try {
                        if (install != null){
                                foreach (string inst in order){
                                        Hashtable state = states [inst];
                                }
                        }
                } catch {
                }
        }
}
</string>
    <string>// cs0266.cs: Cannot implicitly convert type `Helper*' to `Obsolete*'. An explicit conversion exists (are you missing a cast?)
// Line: 18
// Compiler options: -unsafe

class Box {
        public Helper o;
}

unsafe struct Obsolete {
}

unsafe struct Helper {}

class MainClass {
        unsafe public static void Main ()
        {
                Box b = new Box ();
                fixed (Obsolete* p = &amp;b.o)
                {
                }
        }
}
</string>
    <string>// cs0266.cs: Cannot implicitly convert type `object' to `System.Collections.ArrayList'. An explicit conversion exists (are you missing a cast?)
// Line: 12

using System.Collections;

class X
{
	static Hashtable h = new Hashtable ();

	public static void Main ()
	{
		ArrayList l = h ["hola"] = new ArrayList ();
	}
}
</string>
    <string>// cs0266.cs: Cannot implicitly convert type `Bar' to `X'. An explicit conversion exists (are you missing a cast?)
// Line: 18

public enum Bar
{
	ABar
}

class X
{
	public static explicit operator X (Bar the_bar)
	{
		return new X();
	}
	
	public static void Main ()
	{
		X x = Bar.ABar;
	}
}
</string>
    <string>// cs0266.cs: Cannot implicitly convert type `long' to `uint'. An explicit conversion exists (are you missing a cast?)
// Line: 7

namespace MWFTestApplication {
	class MainWindow {
		public enum Testme : uint {
			value   = (1L &lt;&lt; 1)
		}
	}
}
</string>
    <string>// cs0266: Cannot implicitly convert type `long' to `int'. An explicit conversion exists (are you missing a cast?)
// Line : 6

class X {
    const uint a = 2;
    const int b = -a;
}



</string>
    <string>// cs0266-8.cs: Cannot implicitly convert type `void*' to `int*'. An explicit conversion exists (are you missing a cast?)
// Line: 7
// Compiler options: -unsafe

unsafe class MainClass {
	static void *pv = null;
	static int *pi = pv;
        public static void Main () { }
}
</string>
    <string>// CS0266: Cannot implicitly convert type 'E2' to 'E1'. An explicit conversion exists (are you missing a cast?)
// Line : 6

enum E1 { A }
enum E2 { A }

class X {
    const E1 e = ~E2.A;
}



</string>
    <string>// cs0266.cs: Cannot implicitly convert type `Foo.MyEnumType' to `uint'. An explicit conversion exists (are you missing a cast?)
// Line: 11

public class Foo {
  enum MyEnumType { MyValue }

  public void Bar ()
  {
    uint my_uint_var = 0;
    switch (my_uint_var) {
    case MyEnumType.MyValue:
      break;
    default:
      break;
    }
  }

  static void Main () {}
}






</string>
  </Examples>
</ErrorDocumentation>