<?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>CS0019</ErrorName>
  <Examples>
    <string>// cs0019-10.cs: Operator `-' cannot be applied to operands of type `A' and `B'
// Line : 20

enum A
{
        A1,
        A2
}

enum B
{
        B1,
        B2
}

class C
{
        static void Main ()
        {
                System.Console.WriteLine (A.A1 - B.B1);
        }
}
</string>
    <string>// cs0019-11.cs: Operator `&amp;&amp;' cannot be applied to operands of type `null' and `null'
// Line : 8

public class C
{
    public static void Main()
    {
        bool l = (null &amp;&amp; null);
    }
}
</string>
    <string>// cs0019.cs: Operator `*' cannot be applied to operands of type `E' and `E'
// Line : 10

enum E: byte {
	Min
}

class T {
	static void Main () {
		E error = E.Min * E.Min;
	}
}
</string>
    <string>// cs0019.cs: Operator `&gt;&gt;' cannot be applied to operands of type `E' and `int'
// Line : 10

enum E: byte {
	Min
}

class T {
	static void Main () {
		E error = E.Min &gt;&gt; 2;
	}
}
</string>
    <string>// cs0019.cs: Operator `%' cannot be applied to operands of type `E' and `int'
// Line : 10

enum E: byte {
	Min
}

class T {
	static void Main () {
		E error = E.Min % 2;
	}
}
</string>
    <string>// cs0019.cs: Operator `|' cannot be applied to operands of type `int' and `E'
// Line : 10

enum E: byte {
	Min
}

class T {
	static void Main () {
		E error = E.Min | 4;
	}
}
</string>
    <string>// cs0019-16.cs: Operator `&lt;&lt;' cannot be applied to operands of type `byte' and `uint'
// Line: 9

using System;
public class PerformanceTest2 {
	public static void Main () {
		uint j, k;
		j = 0;
		k = ((byte) 1 &lt;&lt; (7 - j % 8));
	}
}
</string>
    <string>// CS0019: Operator `==' cannot be applied to operands of type `int' and `string'
// Line: 8

class S
{
	static int i;
	
	static bool Foo ()
	{
		return i == "";
	}
}
</string>
    <string>// CS0019: Operator `&gt;' cannot be applied to operands of type `bool' and `bool'
// Line: 6

class S
{
	const bool res = true &gt; false;
}
</string>
    <string>// CS0019: Operator `-' cannot be applied to operands of type `float' and `decimal'
// Line: 6

class S
{
	const decimal d = 0f - 1m;
}
</string>
    <string>// cs0019-2.cs: Operator `+' cannot be applied to operands of type `int' and `Test.Zub'
// Line : 11
using System;

class Test {

	enum Zub :byte {
		Foo = 99,
		Bar,
		Baz
	}
	

	static void Main ()
	{
		int v = 1;
		object foo = (v + Zub.Foo);
	}
}
	
</string>
    <string>// CS0019: Operator `-' cannot be applied to operands of type `ulong and `sbyte'
// Line: 6

class S
{
	const ulong u = (ulong)0 - (sbyte)1;
}
</string>
    <string>// CS0019: Operator `+' cannot be applied to operands of type `AA' and `uint'
// Line: 11

enum AA : byte { a, b = 200 }

public class C
{
	public static void Main ()
	{
		const uint ul = 1;
		const AA b = AA.a + ul;
	}
}</string>
    <string>// CS0019: Operator `-' cannot be applied to operands of type `AA' and `long'
// Line: 11

enum AA : short { a, b = 200 }

public class C
{
	public static void Main ()
	{
		const long ul = 1;
		const AA b = AA.a - ul;
	}
}</string>
    <string>// cs0019-3.cs: Operator `+' cannot be applied to operands of type `Test.Zub' and `Test.Zub'
// Line : 11
using System;

class Test {

	enum Zub :byte {
		Foo = 99,
		Bar,
		Baz
	}
	

	static void Main ()
	{
		object v = (Zub.Foo + Zub.Foo);
	}
}
	
</string>
    <string>// cs0019-4.cs: Operator `+' cannot be applied to operands of type `Test.Zub' and `Test.Zub'
// Line : 11
using System;

class Test {

	enum Zub :byte {
		Foo = 99,
		Bar,
		Baz
	}
	

	static void Main ()
	{
		Zub a = Zub.Foo, b = Zub.Bar;
		object v = (a + b);
	}
}
	
</string>
    <string>// cs0019.cs: Operator `==' cannot be applied to operands of type `X' and `Y'
// Line : 13

class X {
}

class Y {
}

class T {
	static void Main ()
	{
		X x = new X ();
		Y y = new Y ();

		if (x == y){
		}
	}
}
</string>
    <string>// cs0019.cs: Operator `==' cannot be applied to operands of type `A' and `B'
// Line : 21

enum A
{
        A1,
        A2
}

enum B
{
        B1,
        B2
}

class C
{
        static void Main ()
        {
                A a = A.A1;
                System.Console.WriteLine (a == B.B1);
        }
}
</string>
    <string>// cs0019-7.cs: Operator `+' cannot be applied to operands of type `string' and `float*'
// Line: 12
// Compiler options: -unsafe
using System;

public class Driver {
  public static void Main () {
    float [] floats = new float[1];
    floats[0] = 1.0f;
    unsafe {
      fixed (float *fp = &amp;floats[0]) {
      Console.WriteLine ("foo" + fp);
      }
    }
  }
}
</string>
    <string>// cs0019-8.cs: Operator `-' cannot be applied to operands of type `string' and `ulong'
// Line : 12

using System;

public class C
{
    public static void Main ()
    {
        ulong aa = 10;
        ulong bb = 3;
        Console.WriteLine("bug here --&gt; "+aa-bb);
    }
}
</string>
    <string>// cs0019.cs: Operator `&amp;' cannot be applied to operands of type `System.Reflection.MethodImplAttributes' and `System.Runtime.CompilerServices.MethodImplOptions'
// Line : 13

//
// From bug #59864 
//
using System.Reflection;
using System.Runtime.CompilerServices;

public class Foo {

	public static void Main ()
	{
		MethodImplAttributes methodImplAttributes = 0;
            
                if ((methodImplAttributes &amp; MethodImplOptions.Synchronized) == 0) {
                }
	}
}
</string>
    <string>// cs0019.cs: Operator `+' cannot be applied to operands of type `Foo' and `int'
// Line : 11

public class Foo {

	public static void Main ()
	{
		
		Foo k = new Foo ();

		int i = k + 6;
		
	}
}
</string>
  </Examples>
</ErrorDocumentation>