text:
package cct.math.expparser;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.nio.CharBuffer;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 *
 * @author vvv900
 */
public class InbuiltClasses implements ClassInterface {

  enum CLASS {

    integer, real, bool, logical, List, Writer, Reader

  }

  private static Map<String, CLASS> allClasses = new HashMap<String, CLASS>();
  private static Map<CLASS, Set<Object>> classMethods = new HashMap<CLASS, Set<Object>>();

  enum LIST_METHOD {

    add, size, get, isEmpty, clear, contains, indexOf, iterator, toArray, lastIndexOf, remove, set
  }

  enum WRITER_METHOD {

    close, flush, newLine, write
  }

  enum READER_METHOD {

    close, mark, markSupported, read, readLine, ready, reset, skip
  }

  private String name;
  private CLASS classType;
  private List list;
  private BufferedWriter bufferedWriter;
  private BufferedReader bufferedReader;

  public InbuiltClasses() {
    if (allClasses.size() == 0) {
      allClasses.put("int", CLASS.integer);
      allClasses.put("INT", CLASS.integer);
      allClasses.put("integer", CLASS.integer);
      allClasses.put("INTEGER", CLASS.integer);
      allClasses.put("real", CLASS.real);
      allClasses.put("REAL", CLASS.real);
      allClasses.put("logical", CLASS.logical);
      allClasses.put("LOGICAL", CLASS.logical);
      allClasses.put("bool", CLASS.logical);
      allClasses.put("BOOL", CLASS.logical);
      allClasses.put("List", CLASS.List);
      allClasses.put("LIST", CLASS.List);
      allClasses.put(CLASS.Writer.name(), CLASS.Writer);
      allClasses.put(CLASS.Writer.name().toUpperCase(), CLASS.Writer);
      allClasses.put(CLASS.Reader.name(), CLASS.Reader);
      allClasses.put(CLASS.Reader.name().toUpperCase(), CLASS.Reader);
      // ---
      classMethods.put(CLASS.List, new HashSet<Object>());
      for (LIST_METHOD lm : LIST_METHOD.values()) {
        classMethods.get(CLASS.List).add(lm);
      }
      classMethods.put(CLASS.Writer, new HashSet<Object>());
      for (WRITER_METHOD wm : WRITER_METHOD.values()) {
        classMethods.get(CLASS.Writer).add(wm);
      }
      classMethods.put(CLASS.Reader, new HashSet<Object>());
      for (READER_METHOD wm : READER_METHOD.values()) {
        classMethods.get(CLASS.Reader).add(wm);
      }
    }
  }

  public InbuiltClasses(CLASS classType, Object[] args) throws Exception {
    this();
    this.classType = classType;
    name = classType.name();
    switch (classType) {
      case List:
        list = new ArrayList();
        return;
      case Writer:
        if (args == null || args.length == 0 || args.length > 2) {
          throw new Exception("Constructor of Class " + classType.name() + " must have either 1 or 2 arguments");
        }
        // ---
        if (args.length == 1) { // File name or something else
          if (args[0] == null) {
            throw new Exception("The first argument of a Constructor of Class " + classType.name()
                + " must be non-zero");
          }
        }
        if (args.length == 2 && args[1] == null) {
          throw new Exception("The second argument of a Constructor of Class " + classType.name()
              + " must be non-zero");
        }
        Boolean append = new Boolean(false);
        if (args.length == 2) {
          if (args[2] instanceof Boolean) {
            append = (Boolean) args[1];
          } else {
            try {
              append = Boolean.parseBoolean(args[1].toString());
            } catch (Exception ex) {
              throw new Exception("The second argument of a Constructor of Class " + classType.name()
                  + " must be of boolean type. Gor: " + args[1].getClass().getCanonicalName());
            }
          }
        }
        bufferedWriter = new BufferedWriter(new FileWriter(args[0].toString(), append));
        return;
      // ---
      case Reader:
        if (args == null || args.length == 0 || args.length > 2) {
          throw new Exception("Constructor of Class " + classType.name() + " must have either 1 or 2 arguments");
        }
        // ---
        if (args.length == 1) { // File name or something else
          if (args[0] == null) {
            throw new Exception("The first argument of a Constructor of Class " + classType.name()
                + " must be non-zero");
          }
        }
        if (args.length == 2 && args[1] == null) {
          throw new Exception("The second argument of a Constructor of Class " + classType.name()
              + " must be non-zero");
        }
        Integer sz = new Integer(64 * 1024);
        if (args.length == 2) {
          if (args[2] instanceof Number) {
            sz = ((Number) args[1]).intValue();
            System.out.println("Using buffer size: " + sz);
          } else {
            try {
              sz = Integer.parseInt(args[1].toString());
            } catch (Exception ex) {
              throw new Exception("The second argument of a Constructor of Class " + classType.name()
                  + " must be of integer type. Got: " + args[1].getClass().getCanonicalName());
            }
          }
        }
        bufferedReader = new BufferedReader(new FileReader(args[0].toString()));
        return;
    }
    throw new Exception("Constructor for Class " + classType.name() + " is not implemented");
  }

  public InbuiltClasses(String className) throws Exception {
    this();
    ciSetName(className);
  }

  public ClassInterface ciAllocateClass(Object[] args) throws Exception {

    return new InbuiltClasses(classType, args);
  }

  public Object ciExecuteMethod(String method, Object[] args) throws Exception {
    switch (classType) {
      case List:
        if (!ciHasMethod(method)) {
          throw new Exception("Class of type" + classType.name() + " does not have method \"" + method + "\"");
        }
        if (method.equals(LIST_METHOD.add.name())) {
          if (args.length < 1 || args.length > 2) {
            throw new Exception("\"" + method + "\" of Class " + classType.name() + " has either 1 or 2 arguments");
          }
          if (args.length == 1) {
            return list.add(args[0]);
          } else if (args.length == 2) {
            list.add(((Number) args[0]).intValue(), args[1]);
            return Void.class;
          }
        } else if (method.equals(LIST_METHOD.set.name())) {
          if (args == null || args.length != 2) {
            throw new Exception("\"" + method + "\" of Class " + classType.name() + " has 2 arguments");
          } else if (args.length == 2) {
            return list.set(((Number) args[0]).intValue(), args[1]);

          }// --------
        } else if (method.equals(LIST_METHOD.size.name())) {
          if (args != null && args.length > 0) {
            throw new Exception("\"" + method + "\" of Class " + classType.name() + " has no argument(s)");
          }
          return list.size();
        } else if (method.equals(LIST_METHOD.isEmpty.name())) {
          if (args != null && args.length > 0) {
            throw new Exception("\"" + method + "\" of Class " + classType.name() + " has no argument(s)");
          }
          return list.isEmpty();
        } else if (method.equals(LIST_METHOD.iterator.name())) {
          if (args != null) {
            throw new Exception("\"" + method + "\" of Class " + classType.name() + " has no argument(s)");
          }
          return list.iterator();
        } else if (method.equals(LIST_METHOD.toArray.name())) {
          if (args != null) {
            throw new Exception("\"" + method + "\" of Class " + classType.name() + " has no argument(s)");
          }
          return list.toArray();
        } else if (method.equals(LIST_METHOD.clear.name())) {
          if (args != null && args.length > 0) {
            throw new Exception("\"" + method + "\" of Class " + classType.name() + " has no argument(s)");
          }
          list.clear();
          return Void.class;
        } else if (method.equals(LIST_METHOD.get.name())) {
          if (args == null || args.length != 1) {
            throw new Exception("\"" + method + "\" of Class " + classType.name() + " has only 1 argument");
          }
          return list.get(((Number) args[0]).intValue());

        } else if (method.equals(LIST_METHOD.contains.name())) {
          if (args == null || args.length != 1) {
            throw new Exception("\"" + method + "\" of Class " + classType.name() + " has only 1 argument");
          }
          return list.contains(args[0]);
        } else if (method.equals(LIST_METHOD.remove.name())) {
          if (args == null || args.length != 1) {
            throw new Exception("\"" + method + "\" of Class " + classType.name() + " has only 1 argument");
          }
          if (args[0] instanceof Integer || args[0] instanceof Long || args[0] instanceof Short) {
            return list.remove(((Number) args[0]).intValue());
          } else {
            return list.remove(args[0]);
          }
        } else if (method.equals(LIST_METHOD.lastIndexOf.name())) {
          if (args == null || args.length != 1) {
            throw new Exception("\"" + method + "\" of Class " + classType.name() + " has only 1 argument");
          }
          return list.lastIndexOf(args[0]);
        } else if (method.equals(LIST_METHOD.indexOf.name())) {
          if (args == null || args.length != 1) {
            throw new Exception("\"" + method + "\" of Class " + classType.name() + " has only 1 argument");
          }
          return list.indexOf(args[0]);
        }
        break;
      // ----
      case Writer:
        return executeWriterMethod(method, args);
      // ----
      case Reader:
        return executeReaderMethod(method, args);
    }
    throw new Exception("\"" + method + "\" of Class " + classType.name() + " is not implemented");
  }

  public String ciGetName() {
    return name;
  }

  public void ciSetName(String name) throws Exception {
    if (!allClasses.containsKey(name)) {
      throw new Exception("There is no inbuilt type " + name);
    }
    this.classType = allClasses.get(name);
    name = classType.name();
    switch (classType) {
      case List:
        list = new ArrayList();
        break;
    }
  }

  public String[] ciGetAllMethods() {
    Object[] obj;
    String[] methods;
    obj = classMethods.get(classType).toArray();
    methods = new String[obj.length];
    for (int i = 0; i < obj.length; i++) {
      methods[i] = obj[i].toString();
    }
    return methods;
  }

  public boolean ciHasMethod(String methodName) {
    try {
      switch (classType) {
        case List:
          LIST_METHOD.valueOf(methodName);
          return true;
        //return classMethods.get(classType).contains(methodName);
        case Writer:
          WRITER_METHOD.valueOf(methodName);
          return true;
        //return classMethods.get(classType).contains(methodName);
        case Reader:
          READER_METHOD.valueOf(methodName);
          return true;
      }
    } catch (Exception ex) {
    }
    return false;
  }

  public void ciSetExpressionParser(ExpressionParser expressionParser) {

  }

  public Object executeWriterMethod(String method, Object[] args) throws Exception {
    WRITER_METHOD wm = WRITER_METHOD.valueOf(method);
    switch (wm) {
      case close:
        if (args != null && args.length > 0) {
          throw new Exception("\"" + method + "\" of Class " + classType.name() + " has no argument(s)");
        }
        bufferedWriter.close();
        return Void.class;

      case flush:
        if (args != null && args.length > 0) {
          throw new Exception("\"" + method + "\" of Class " + classType.name() + " has no argument(s)");
        }
        bufferedWriter.flush();
        return Void.class;

      case newLine:
        if (args != null && args.length > 0) {
          throw new Exception("\"" + method + "\" of Class " + classType.name() + " has no argument(s)");
        }
        bufferedWriter.newLine();
        return Void.class;

      case write:
        if (args == null || args.length == 2) {
          throw new Exception("\"" + method + "\" of Class " + classType.name() + " must have either 1 or 3 arguments");
        }
        if (args.length > 3) {
          throw new Exception("\"" + method + "\" of Class " + classType.name() + " cannot have more than 3 arguments");
        }
        // ---
        if (args.length == 1) {
          if (args[0] instanceof char[]) {
            bufferedWriter.write((char[]) args[0]);
          } else if (args[0] instanceof Integer || args[0] instanceof Long || args[0] instanceof Short) {
            bufferedWriter.write(((Number) args[0]).intValue());
          } else {
            bufferedWriter.write(args[0].toString());
          }
          return Void.class;
        }
    }
    throw new Exception("\"" + method + "\" of Class " + classType.name() + " is not implemented");
  }

  public Object executeReaderMethod(String method, Object[] args) throws Exception {
    READER_METHOD rm = READER_METHOD.valueOf(method); //mark, read, ready, reset, skip
    switch (rm) {
      case close:
        if (args != null && args.length > 0) {
          throw new Exception("\"" + method + "\" of Class " + classType.name() + " has no argument(s)");
        }
        bufferedReader.close();
        return Void.class;

      case markSupported:
        if (args != null && args.length > 0) {
          throw new Exception("\"" + method + "\" of Class " + classType.name() + " has no argument(s)");
        }
        return bufferedReader.markSupported();

      case ready:
        if (args != null && args.length > 0) {
          throw new Exception("\"" + method + "\" of Class " + classType.name() + " has no argument(s)");
        }
        return bufferedReader.ready();

      case reset:
        if (args != null && args.length > 0) {
          throw new Exception("\"" + method + "\" of Class " + classType.name() + " has no argument(s)");
        }
        bufferedReader.reset();
        return Void.class;

      case readLine:
        if (args != null && args.length > 0) {
          throw new Exception("\"" + method + "\" of Class " + classType.name() + " has no argument(s)");
        }
        return bufferedReader.readLine();

      case mark:
        if (args != null || args.length != 1 || args[0] == null) {
          throw new Exception("\"" + method + "\" of Class " + classType.name() + " must have one argument");
        }
        if (args[0] instanceof Number) {
          bufferedReader.mark(((Number) args[0]).intValue());
          return Void.class;
        }
        int readAheadLimit = Integer.parseInt(args[0].toString());
        bufferedReader.mark(readAheadLimit);
        return Void.class;

      case skip:
        if (args != null || args.length != 1 || args[0] == null) {
          throw new Exception("\"" + method + "\" of Class " + classType.name() + " must have one argument");
        }
        if (args[0] instanceof Number) {
          return bufferedReader.skip(((Number) args[0]).longValue());
        }
        long n = Long.parseLong(args[0].toString());
        return bufferedReader.skip(n);

      case read:
        if (args == null || args.length == 0) {
          return bufferedReader.read();
        }

        if (args == null || args.length == 1) {
          if (args[0] == null) {
            throw new Exception("\"" + method + "\"(buffer) of Class " + classType.name() + ":  buffer must be non-zero");
          }
          if (args[0] instanceof char[]) {
            return bufferedReader.read((char[]) args[0]);
          } else if (args[0] instanceof CharBuffer) {
            return bufferedReader.read((CharBuffer) args[0]);
          }
          throw new Exception("\"" + method + "\"(buffer) of Class " + classType.name() + ":  buffer must be of type "
              + "char[] or CharBuffer. Got: " + args[0].getClass().getCanonicalName());
        }
        // ---
        if (args.length != 3) {
          throw new Exception("\"" + method + "\" of Class " + classType.name() + " cannot can have 0, 1 or 3 arguments");
        }
        // ---
        int off = ((Number) args[1]).intValue();
        int len = ((Number) args[2]).intValue();

        if (args[0] instanceof char[]) {
          return bufferedReader.read((char[]) args[0], off, len);
        }
        throw new Exception("\"" + method + "\"(char[] cbuf, int off, int len) of Class " + classType.name()
            + " check parameters type");

    }
    throw new Exception("\"" + method + "\" of Class " + classType.name() + " is not implemented");
  }
}


text:
package cmd

import (
	"fmt"
	"io"
	"sort"
	"strings"

	"github.com/spf13/cobra"

	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/apimachinery/pkg/runtime/schema"
	"k8s.io/apimachinery/pkg/util/sets"
	"k8s.io/kubernetes/pkg/kubectl/cmd/templates"
	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
	"k8s.io/kubernetes/pkg/kubectl/genericclioptions"
	"k8s.io/kubernetes/pkg/printers"
)

var (
	apiresources_example = templates.Examples(`
		# Print the supported API Resources
		kubectl api-resources

		# Print the supported API Resources with more information
		kubectl api-resources -o wide

		# Print the supported namespaced resources
		kubectl api-resources --namespaced=true

		# Print the supported non-namespaced resources
		kubectl api-resources --namespaced=false

		# Print the supported API Resources with specific APIGroup
		kubectl api-resources --api-group=extensions`)
)

// ApiResourcesOptions is the start of the data required to perform the operation.  As new fields are added, add them here instead of
// referencing the cmd.Flags()
type ApiResourcesOptions struct {
	Output     string
	APIGroup   string
	Namespaced bool
	Verbs      []string
	NoHeaders  bool

	genericclioptions.IOStreams
}

// groupResource contains the APIGroup and APIResource
type groupResource struct {
	APIGroup    string
	APIResource metav1.APIResource
}

func NewAPIResourceOptions(ioStreams genericclioptions.IOStreams) *ApiResourcesOptions {
	return &ApiResourcesOptions{
		IOStreams: ioStreams,
	}
}

func NewCmdApiResources(f cmdutil.Factory, ioStreams genericclioptions.IOStreams) *cobra.Command {
	o := NewAPIResourceOptions(ioStreams)

	cmd := &cobra.Command{
		Use:     "api-resources",
		Short:   "Print the supported API resources on the server",
		Long:    "Print the supported API resources on the server",
		Example: apiresources_example,
		Run: func(cmd *cobra.Command, args []string) {
			cmdutil.CheckErr(o.Complete(cmd))
			cmdutil.CheckErr(o.Validate(cmd))
			cmdutil.CheckErr(o.RunApiResources(cmd, f))
		},
	}
	cmdutil.AddOutputFlags(cmd)
	cmdutil.AddNoHeadersFlags(cmd)
	cmd.Flags().StringVar(&o.APIGroup, "api-group", "", "Limit to resources in the specified API group.")
	cmd.Flags().BoolVar(&o.Namespaced, "namespaced", true, "Namespaced indicates if a resource is namespaced or not.")
	cmd.Flags().StringSliceVar(&o.Verbs, "verbs", o.Verbs, "Limit to resources that support the specified verbs.")
	return cmd
}

func (o *ApiResourcesOptions) Complete(cmd *cobra.Command) error {
	o.Output = cmdutil.GetFlagString(cmd, "output")
	o.NoHeaders = cmdutil.GetFlagBool(cmd, "no-headers")
	return nil
}

func (o *ApiResourcesOptions) Validate(cmd *cobra.Command) error {
	validOutputTypes := sets.NewString("", "json", "yaml", "wide", "name", "custom-columns", "custom-columns-file", "go-template", "go-template-file", "jsonpath", "jsonpath-file")
	supportedOutputTypes := sets.NewString("", "wide", "name")
	outputFormat := cmdutil.GetFlagString(cmd, "output")
	if !validOutputTypes.Has(outputFormat) {
		return fmt.Errorf("output must be one of '' or 'wide': %v", outputFormat)
	}
	if !supportedOutputTypes.Has(outputFormat) {
		return fmt.Errorf("--output %v is not available in kubectl api-resources", outputFormat)
	}
	return nil
}

func (o *ApiResourcesOptions) RunApiResources(cmd *cobra.Command, f cmdutil.Factory) error {
	w := printers.GetNewTabWriter(o.Out)
	defer w.Flush()

	discoveryclient, err := f.DiscoveryClient()
	if err != nil {
		return err
	}

	// Always request fresh data from the server
	discoveryclient.Invalidate()

	lists, err := discoveryclient.ServerPreferredResources()
	if err != nil {
		return err
	}

	resources := []groupResource{}

	groupChanged := cmd.Flags().Changed("api-group")
	nsChanged := cmd.Flags().Changed("namespaced")

	for _, list := range lists {
		if len(list.APIResources) == 0 {
			continue
		}
		gv, err := schema.ParseGroupVersion(list.GroupVersion)
		if err != nil {
			continue
		}
		for _, resource := range list.APIResources {
			if len(resource.Verbs) == 0 {
				continue
			}
			// filter apiGroup
			if groupChanged && o.APIGroup != gv.Group {
				continue
			}
			// filter namespaced
			if nsChanged && o.Namespaced != resource.Namespaced {
				continue
			}
			// filter to resources that support the specified verbs
			if len(o.Verbs) > 0 && !sets.NewString(resource.Verbs...).HasAll(o.Verbs...) {
				continue
			}
			resources = append(resources, groupResource{
				APIGroup:    gv.Group,
				APIResource: resource,
			})
		}
	}

	if o.NoHeaders == false && o.Output != "name" {
		if err = printContextHeaders(w, o.Output); err != nil {
			return err
		}
	}

	sort.Stable(sortableGroupResource(resources))
	for _, r := range resources {
		switch o.Output {
		case "name":
			name := r.APIResource.Name
			if len(r.APIGroup) > 0 {
				name += "." + r.APIGroup
			}
			if _, err := fmt.Fprintf(w, "%s\n", name); err != nil {
				return err
			}
		case "wide":
			if _, err := fmt.Fprintf(w, "%s\t%s\t%s\t%v\t%s\t%v\n",
				r.APIResource.Name,
				strings.Join(r.APIResource.ShortNames, ","),
				r.APIGroup,
				r.APIResource.Namespaced,
				r.APIResource.Kind,
				r.APIResource.Verbs); err != nil {
				return err
			}
		case "":
			if _, err := fmt.Fprintf(w, "%s\t%s\t%s\t%v\t%s\n",
				r.APIResource.Name,
				strings.Join(r.APIResource.ShortNames, ","),
				r.APIGroup,
				r.APIResource.Namespaced,
				r.APIResource.Kind); err != nil {
				return err
			}
		}
	}
	return nil
}

func printContextHeaders(out io.Writer, output string) error {
	columnNames := []string{"NAME", "SHORTNAMES", "APIGROUP", "NAMESPACED", "KIND"}
	if output == "wide" {
		columnNames = append(columnNames, "VERBS")
	}
	_, err := fmt.Fprintf(out, "%s\n", strings.Join(columnNames, "\t"))
	return err
}

type sortableGroupResource []groupResource

func (s sortableGroupResource) Len() int      { return len(s) }
func (s sortableGroupResource) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
func (s sortableGroupResource) Less(i, j int) bool {
	ret := strings.Compare(s[i].APIGroup, s[j].APIGroup)
	if ret > 0 {
		return false
	} else if ret == 0 {
		return strings.Compare(s[i].APIResource.Name, s[j].APIResource.Name) < 0
	}
	return true
}

redpajama_set_name: RedPajamaGithub


text:
@interface ZJUInfoListViewController : ZJUBaseTableViewController

@end


text:
<?php
/**
 * VariableFactory.php
 * Factory to generate \Ruler\Variable instances.
 *
 * @author Zachary Burnham zburnham@gmail.com
 */

namespace ZFRuler\Factory;

use Ruler\Variable;

class VariableFactory
{
    /**
     * @param string $name
     * @param mixed $value
     *
     * @return Variable
     */
    public function create($name = null, $value = null)
    {
        return new Variable($name, $value);
    }
}


text:
<!doctype html>
<title>/resources/media/gamut/gamut-theora-bt470.ogv</title>

FAIL (script didn't run)


text:
describe('zoomAnimation', function () {
	var map, div, clock;
	beforeEach(function () {
		clock = sinon.useFakeTimers();

		div = document.createElement('div');
		div.style.width = '200px';
		div.style.height = '200px';
		document.body.appendChild(div);

		map = L.map(div, { maxZoom: 18 });
	});
	afterEach(function () {
		clock.restore();

		document.body.removeChild(div);
	});

	it('adds the visible marker to the map when zooming in', function () {
		map.setView(new L.LatLng(-37.36142550190516, 174.254150390625), 7);

		var markers = new L.MarkerClusterGroup({
			showCoverageOnHover: true,
			maxClusterRadius: 20,
			disableClusteringAtZoom: 15
		});
		var marker = new L.Marker([-37.77852090603777, 175.3103667497635]);
		markers.addLayer(marker); //The one we zoom in on
		markers.addLayer(new L.Marker([-37.711800591811055, 174.50034790039062])); //Marker that we cluster with at the top zoom level, but not 1 level down
		map.addLayer(markers);

		clock.tick(1000);
		map.setView([-37.77852090603777, 175.3103667497635], 15);

		//Run the the animation
		clock.tick(1000);

		expect(marker._icon).to.not.be(undefined);
		expect(marker._icon).to.not.be(null);
	});

	it('adds the visible marker to the map when jumping around', function () {

		var markers = new L.MarkerClusterGroup();
		var marker1 = new L.Marker([48.858280181884766, 2.2945759296417236]);
		var marker2 = new L.Marker([16.02359962463379, -61.70280075073242]);
		markers.addLayer(marker1); //The one we zoom in on first
		markers.addLayer(marker2); //Marker that we cluster with at the top zoom level, but not 1 level down
		map.addLayer(markers);

		//show the first
		map.fitBounds(new L.LatLngBounds(new L.LatLng(41.371582, -5.142222), new L.LatLng(51.092804, 9.561556)));

		clock.tick(1000);

		map.fitBounds(new L.LatLngBounds(new L.LatLng(15.830972671508789, -61.807167053222656), new L.LatLng(16.516849517822266, -61.0)));

		//Run the the animation
		clock.tick(1000);

		//Now the second one should be visible on the map
		expect(marker2._icon).to.not.be(undefined);
		expect(marker2._icon).to.not.be(null);
	});

	it('adds the visible markers to the map, but not parent clusters when jumping around', function () {

		var markers = new L.MarkerClusterGroup(),
			marker1 = new L.Marker([59.9520, 30.3307]),
			marker2 = new L.Marker([59.9516, 30.3308]),
			marker3 = new L.Marker([59.9513, 30.3312]);

		markers.addLayer(marker1);
		markers.addLayer(marker2);
		markers.addLayer(marker3);
		map.addLayer(markers);

		//Show none of them
		map.setView([53.0676, 170.6835], 16);

		clock.tick(1000);

		//Zoom so that all the markers will be visible (Same as zoomToShowLayer)
		map.setView(marker1.getLatLng(), 18);

		//Run the the animation
		clock.tick(1000);

		//Now the markers should all be visible, and there should be no visible clusters
		expect(marker1._icon.parentNode).to.be(map._panes.markerPane);
		expect(marker2._icon.parentNode).to.be(map._panes.markerPane);
		expect(marker3._icon.parentNode).to.be(map._panes.markerPane);
		expect(map._panes.markerPane.childNodes.length).to.be(3);
	});
});


text:
package org.motechproject.openmrs19.resource.model;

import java.util.List;

/**
 * Stores a list of {@link Encounter}s. This class is used as a result of a query to the OpenMRS server.
 */
public class EncounterListResult {

    private List<Encounter> results;

    public List<Encounter> getResults() {
        return results;
    }

    public void setResults(List<Encounter> results) {
        this.results = results;
    }
}


text:
<?php

/** Exit if accessed directly */
if ( ! defined( 'ABSPATH' ) ) exit( 'Cheatin’ uh?' );

/**
 * Include the TGM_Plugin_Activation class.
 */
require_once dirname( __FILE__ ) . '/class-tgm-plugin-activation.php';

add_action( 'tgmpa_register', 'gs_register_required_plugins' );
/**
 * Register the required plugins for this theme.
 *
 * In this example, we register two plugins - one included with the TGMPA library
 * and one from the .org repo.
 *
 * The variable passed to tgmpa_register_plugins() should be an array of plugin
 * arrays.
 *
 * This function is hooked into tgmpa_init, which is fired within the
 * TGM_Plugin_Activation class constructor.
 */
function gs_register_required_plugins() {

	/**
	 * Array of plugin arrays. Required keys are name and slug.
	 * If the source is NOT from the .org repo, then source is also required.
	 */
	$plugins = array(

		// This is an example of how to include a plugin pre-packaged with a theme (like a core functionality plugin)
		/*
		array(
			'name'     				=> 'TGM Example Plugin', // The plugin name
			'slug'     				=> 'tgm-example-plugin', // The plugin slug (typically the folder name)
			'source'   				=> CHILD_LIB_DIR . '/plugins/tgm-example-plugin.zip', // The plugin source
			'required' 				=> true, // If false, the plugin is only 'recommended' instead of required
			'version' 				=> '', // E.g. 1.0.0. If set, the active plugin must be this version or higher, otherwise a notice is presented
			'force_activation' 		=> false, // If true, plugin is activated upon theme activation and cannot be deactivated until theme switch
			'force_deactivation' 	=> false, // If true, plugin is deactivated upon theme switch, useful for theme-specific plugins
			'external_url' 			=> '', // If set, overrides default API URL and points to an external URL
		),
		*/

		// This is an example of how to include a plugin from the WordPress Plugin Repository
		array(
			'name' 		=> 'Genesis Shortcodes',
			'slug' 		=> 'genesis-shortcodes',
			'required' 	=> true,
		),

	);

	/**
	 * Array of configuration settings. Amend each line as needed.
	 * If you want the default strings to be available under your own theme domain,
	 * leave the strings uncommented.
	 * Some of the strings are added into a sprintf, so see the comments at the
	 * end of each line for what each argument will be.
	 */
	$config = array(
		'domain'       		=> CHILD_DOMAIN,         	// Text domain - likely want to be the same as your theme.
		'default_path' 		=> '',                         	// Default absolute path to pre-packaged plugins
		'parent_menu_slug' 	=> 'themes.php', 				// Default parent menu slug
		'parent_url_slug' 	=> 'themes.php', 				// Default parent URL slug
		'menu'         		=> 'install-required-plugins', 	// Menu slug
		'has_notices'      	=> true,                       	// Show admin notices or not
		'is_automatic'    	=> false,					   	// Automatically activate plugins after installation or not
		'message' 			=> '',							// Message to output right before the plugins table
		'strings'      		=> array(
			'page_title'                       			=> __( 'Install Required Plugins', CHILD_DOMAIN ),
			'menu_title'                       			=> __( 'Install Plugins', CHILD_DOMAIN ),
			'installing'                       			=> __( 'Installing Plugin: %s', CHILD_DOMAIN ), // %1$s = plugin name
			'oops'                             			=> __( 'Something went wrong with the plugin API.', CHILD_DOMAIN ),
			'notice_can_install_required'     			=> _n_noop( 'This theme requires the following plugin: %1$s.', 'This theme requires the following plugins: %1$s.' ), // %1$s = plugin name(s)
			'notice_can_install_recommended'			=> _n_noop( 'This theme recommends the following plugin: %1$s.', 'This theme recommends the following plugins: %1$s.' ), // %1$s = plugin name(s)
			'notice_cannot_install'  					=> _n_noop( 'Sorry, but you do not have the correct permissions to install the %s plugin. Contact the administrator of this site for help on getting the plugin installed.', 'Sorry, but you do not have the correct permissions to install the %s plugins. Contact the administrator of this site for help on getting the plugins installed.' ), // %1$s = plugin name(s)
			'notice_can_activate_required'    			=> _n_noop( 'The following required plugin is currently inactive: %1$s.', 'The following required plugins are currently inactive: %1$s.' ), // %1$s = plugin name(s)
			'notice_can_activate_recommended'			=> _n_noop( 'The following recommended plugin is currently inactive: %1$s.', 'The following recommended plugins are currently inactive: %1$s.' ), // %1$s = plugin name(s)
			'notice_cannot_activate' 					=> _n_noop( 'Sorry, but you do not have the correct permissions to activate the %s plugin. Contact the administrator of this site for help on getting the plugin activated.', 'Sorry, but you do not have the correct permissions to activate the %s plugins. Contact the administrator of this site for help on getting the plugins activated.' ), // %1$s = plugin name(s)
			'notice_ask_to_update' 						=> _n_noop( 'The following plugin needs to be updated to its latest version to ensure maximum compatibility with this theme: %1$s.', 'The following plugins need to be updated to their latest version to ensure maximum compatibility with this theme: %1$s.' ), // %1$s = plugin name(s)
			'notice_cannot_update' 						=> _n_noop( 'Sorry, but you do not have the correct permissions to update the %s plugin. Contact the administrator of this site for help on getting the plugin updated.', 'Sorry, but you do not have the correct permissions to update the %s plugins. Contact the administrator of this site for help on getting the plugins updated.' ), // %1$s = plugin name(s)
			'install_link' 					  			=> _n_noop( 'Begin installing plugin', 'Begin installing plugins' ),
			'activate_link' 				  			=> _n_noop( 'Activate installed plugin', 'Activate installed plugins' ),
			'return'                           			=> __( 'Return to Required Plugins Installer', CHILD_DOMAIN ),
			'plugin_activated'                 			=> __( 'Plugin activated successfully.', CHILD_DOMAIN ),
			'complete' 									=> __( 'All plugins installed and activated successfully. %s', CHILD_DOMAIN ), // %1$s = dashboard link
			'nag_type'									=> 'updated' // Determines admin notice type - can only be 'updated' or 'error'
		)
	);

	tgmpa( $plugins, $config );

}


text:
/* Native-code renderers
 *
 * $Id$ */

#include <Python.h>
#include <structmember.h>
#include <math.h>

#include <GL/glew.h>
#ifdef _WIN32
#include <windows.h>
#endif

#ifdef __APPLE__
#include <OpenGL/gl.h>
#include <OpenGL/glu.h>
#else
#include <GL/gl.h>
#include <GL/glu.h>
#endif

#include "vector.h"
#include "group.h"
#include "renderer.h"

typedef struct {
	PyObject_HEAD
	PyObject *texturizer;
} RendererObject;

int
glew_initialize(void)
{
	static int glew_initd = 0;

	if (!glew_initd) {
		if (glewInit() != GLEW_OK) {
			PyErr_SetString(PyExc_RuntimeError, "GLEW initialization failed");
			return 0;
		}
		glew_initd = 1;
	}
	return 1;
}

/* --------------------------------------------------------------------- */

/* Vertex data functions and structs */

typedef struct {
	float x, y, z;
} VertItem;

typedef struct {
	unsigned char r, g, b, a;
} ColorSwizzle;

typedef struct {
	union {
		ColorSwizzle rgba;
		unsigned long colorl;
	};
} ColorItem;

typedef struct {
	int is_vbo;
	Py_ssize_t size; /* Number of verts */
	VertItem *verts;
	ColorItem *colors;
} VertArray;

/* Allocate space for vertex data for the given particle group
   and texture dimension. Store the results in data.

   Return 1 on success, 0 on failure
*/
static int
VertArray_alloc(GroupObject *pgroup, VertArray *data)
{
	data->size = GroupObject_ActiveCount(pgroup) * 4;
	data->is_vbo = 0;
	data->verts = (VertItem *)PyMem_Malloc(
		data->size*sizeof(VertItem) + /* vert data */
		data->size*sizeof(ColorItem)  /* color data */
		);
	if (data->verts != NULL) {
		data->colors = (ColorItem *)(data->verts + data->size);
		return 1;
	} else {
		PyErr_NoMemory();
		return 0;
	}
}

static void
VertArray_free(VertArray *data)
{
	if (!data->is_vbo)
		PyMem_Free((void *)data->verts);
}

/* --------------------------------------------------------------------- */

/* A float array provides a simple interface from python to
   an arbitrary fixed-sized array of C floats. This underlying
   array data itself is not owned by this object, it is managed
   outside by other parts of the system, or the graphics driver
   itself. This prevents us from using an existing array type
*/
static PyTypeObject FloatArray_Type;

int
FloatArrayObject_Check(FloatArrayObject *o)
{
	if (o->ob_type != &FloatArray_Type) {
		PyErr_SetString(PyExc_TypeError, "Expected FloatArray object");
		return 0;
	}
	return 1;
}

FloatArrayObject *
FloatArray_new(Py_ssize_t size)
{
	FloatArrayObject *floatarray;

	floatarray = PyObject_New(FloatArrayObject, &FloatArray_Type);
	if (floatarray == NULL)
		return (FloatArrayObject *)PyErr_NoMemory();
	floatarray->size = size;
	floatarray->data = PyMem_Malloc(sizeof(float) * size);
	if (floatarray->data == NULL)
		Py_CLEAR(floatarray);
	return floatarray;
}

static void
FloatArray_dealloc(FloatArrayObject *self)
{
	PyMem_Free(self->data);
	self->data = NULL;
	PyObject_Del(self);
}

static PyObject *
FloatArray_getitem(FloatArrayObject *self, Py_ssize_t index)
{
	if (index >= 0 && index < self->size)
		return PyFloat_FromDouble((double)self->data[index]);
	PyErr_Format(PyExc_IndexError, "%d", (int)index);
	return NULL;
}

static int
FloatArray_assitem(FloatArrayObject *self, Py_ssize_t index, PyObject *v)
{
	float f;
	if (index >= 0 && index < self->size) {
		 f = (float)PyFloat_AsDouble(v);
		 if (PyErr_Occurred() != NULL)
		 	return -1;
		 self->data[index] = f;
		 return 0;
	}
	PyErr_Format(PyExc_IndexError, "%d", (int)index);
	return -1;
}

static Py_ssize_t
FloatArray_length(FloatArrayObject *self)
{
	return (Py_ssize_t)self->size;
}

static PySequenceMethods FloatArray_as_sequence = {
	(lenfunc)FloatArray_length,	/* sq_length */
	0,		/*sq_concat*/
	0,		/*sq_repeat*/
	(ssizeargfunc)FloatArray_getitem,		/*sq_item*/
	0,		/* sq_slice */
	(ssizeobjargproc)FloatArray_assitem,	/* sq_ass_item */
};

PyDoc_STRVAR(FloatArray__doc__, "Fixed length float array");

static PyTypeObject FloatArray_Type = {
	/* The ob_type field must be initialized in the module init function
	 * to be portable to Windows without using C++. */
	PyObject_HEAD_INIT(NULL)
	0,			                /*ob_size*/
	"renderer.FloatArray",		/*tp_name*/
	sizeof(FloatArrayObject),	/*tp_basicsize*/
	0,			                /*tp_itemsize*/
	/* methods */
	(destructor)FloatArray_dealloc, /*tp_dealloc*/
	0,			            /*tp_print*/
	0,                      /*tp_getattr*/
	0,                      /*tp_setattr*/
	0,			            /*tp_compare*/
	0,                      /*tp_repr*/
	0,			            /*tp_as_number*/
	&FloatArray_as_sequence,    /*tp_as_sequence*/
	0,			            /*tp_as_mapping*/
	0,			            /*tp_hash*/
	0,                      /*tp_call*/
	0,                      /*tp_str*/
	0,                      /*tp_getattro*/
	0,                      /*tp_setattro*/
	0,                      /*tp_as_buffer*/
	Py_TPFLAGS_DEFAULT,     /*tp_flags*/
	FloatArray__doc__,   /*tp_doc*/
	0,                      /*tp_traverse*/
	0,                      /*tp_clear*/
	0,                      /*tp_richcompare*/
	0,                      /*tp_weaklistoffset*/
	0,                      /*tp_iter*/
	0,                      /*tp_iternext*/
	0,                      /*tp_methods*/
	0,                      /*tp_members*/
	0,                      /*tp_getset*/
	0,                      /*tp_base*/
	0,                      /*tp_dict*/
	0,                      /*tp_descr_get*/
	0,                      /*tp_descr_set*/
	0,                      /*tp_dictoffset*/
	0, /*(initproc)FloatArray_init,*/ /*tp_init*/
	0,                      /*tp_alloc*/
	0,                      /*tp_new*/
	0,                      /*tp_free*/
	0,                      /*tp_is_gc*/
};

/* --------------------------------------------------------------------- */

static PyTypeObject PointRenderer_Type;

typedef struct {
	PyObject_HEAD
	float	 point_size;
	PyObject *texturizer;
} PointRendererObject;

static void
PointRenderer_dealloc(PointRendererObject *self)
{
	Py_CLEAR(self->texturizer);
	PyObject_Del(self);
}

static int
PointRenderer_init(PointRendererObject *self, PyObject *args, PyObject *kwargs)
{
	static char *kwlist[] = {"point_size", "texturizer", NULL};

	self->texturizer = NULL;
	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "f|O:__init__",kwlist,
		&self->point_size, &self->texturizer))
		return -1;
	if (self->texturizer == Py_None)
		self->texturizer = NULL;
	if (self->texturizer != NULL)
		Py_INCREF(self->texturizer);
	return 0;
}

static PyObject *
PointRenderer_draw(PointRendererObject *self, GroupObject *pgroup)
{
	Particle *p;
	PyObject *r = NULL;
	int GL_error;
	unsigned long count_particles;

	if (!GroupObject_Check(pgroup)) {
		PyErr_SetString(PyExc_TypeError, "Expected ParticleGroup first argument");
		return NULL;
	}

	if (!glew_initialize())
		return NULL;

	count_particles = GroupObject_ActiveCount(pgroup);
	if (count_particles > 0){
		p = pgroup->plist->p;
		if (self->texturizer != NULL) {
			r = PyObject_CallMethod(self->texturizer, "set_state", NULL);
			if (r == NULL)
				return NULL;
			Py_DECREF(r);
			glEnable(GL_POINT_SPRITE);
			glTexEnvi(GL_POINT_SPRITE, GL_COORD_REPLACE, GL_TRUE);
		}

		glPushClientAttrib(GL_CLIENT_VERTEX_ARRAY_BIT);
		glEnableClientState(GL_VERTEX_ARRAY);
		glEnableClientState(GL_COLOR_ARRAY);
		glPointSize(self->point_size);
		glVertexPointer(3, GL_FLOAT, sizeof(Particle), &p[0].position);
		glColorPointer(4, GL_FLOAT, sizeof(Particle), &p[0].color);
		glDrawArrays(GL_POINTS, 0, GroupObject_ActiveCount(pgroup));
		glPopClientAttrib();

		GL_error = glGetError();
		if (GL_error != GL_NO_ERROR) {
			PyErr_Format(PyExc_RuntimeError, "GL error %d", GL_error);
			return NULL;
		}

		if (self->texturizer != NULL) {
			r = PyObject_CallMethod(self->texturizer, "restore_state", NULL);
			if (r == NULL)
				return NULL;
			Py_DECREF(r);
		}
	}
	Py_INCREF(Py_None);
	return Py_None;
}

static struct PyMemberDef PointRenderer_members[] = {
    {"point_size", T_FLOAT, offsetof(PointRendererObject, point_size), 0,
        "Size of GL_POINTS drawn"},
    {"texturizer", T_OBJECT, offsetof(PointRendererObject, texturizer), 0,
        "Texturizer used to apply texture to particles"},
	{NULL}
};

static PyMethodDef PointRenderer_methods[] = {
	{"draw", (PyCFunction)PointRenderer_draw, METH_O,
		PyDoc_STR("Draw the particles in the specified group using GL_POINTS")},
	{NULL,		NULL}		/* sentinel */
};

PyDoc_STRVAR(PointRenderer__doc__,
	"Simple particle renderer using GL_POINTS. All particles in the\n"
	"group are rendered with the same point size\n\n"
	"PointRenderer(point_size, texturizer=None)\n\n"
	"point_size -- Size of GL_POINTS points to draw (float)\n\n"
	"texturizer -- Texturizer used to apply texture to particles.\n"
	"If specified, the points are drawn using GL_POINT_SPRITES.\n"
	"Note that point sprites have fixed texture coordinates,\n"
	"thus they cannot use custom per-particle coordinates\n"
	"computed by the texturizer.");

static PyTypeObject PointRenderer_Type = {
	/* The ob_type field must be initialized in the module init function
	 * to be portable to Windows without using C++. */
	PyObject_HEAD_INIT(NULL)
	0,			/*ob_size*/
	"renderer.PointRenderer",		/*tp_name*/
	sizeof(PointRendererObject),	/*tp_basicsize*/
	0,			/*tp_itemsize*/
	/* methods */
	(destructor)PointRenderer_dealloc, /*tp_dealloc*/
	0,			/*tp_print*/
	0,          /*tp_getattr*/
	0,          /*tp_setattr*/
	0,			/*tp_compare*/
	0,			/*tp_repr*/
	0,			/*tp_as_number*/
	0,	        /*tp_as_sequence*/
	0,			/*tp_as_mapping*/
	0,			/*tp_hash*/
	0,                      /*tp_call*/
	0,                      /*tp_str*/
	0,                      /*tp_getattro*/
	0,                      /*tp_setattro*/
	0,                      /*tp_as_buffer*/
	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
	PointRenderer__doc__,   /*tp_doc*/
	0,                      /*tp_traverse*/
	0,                      /*tp_clear*/
	0,                      /*tp_richcompare*/
	0,                      /*tp_weaklistoffset*/
	0,                      /*tp_iter*/
	0,                      /*tp_iternext*/
	PointRenderer_methods,  /*tp_methods*/
	PointRenderer_members,  /*tp_members*/
	0,                      /*tp_getset*/
	0,                      /*tp_base*/
	0,                      /*tp_dict*/
	0,                      /*tp_descr_get*/
	0,                      /*tp_descr_set*/
	0,                      /*tp_dictoffset*/
	(initproc)PointRenderer_init, /*tp_init*/
	0,                      /*tp_alloc*/
	0,                      /*tp_new*/
	0,                      /*tp_free*/
	0,                      /*tp_is_gc*/
};

/* --------------------------------------------------------------------- */

static PyTypeObject BillboardRenderer_Type;

static void
BillboardRenderer_dealloc(RendererObject *self)
{
	Py_CLEAR(self->texturizer);
	PyObject_Del(self);
}

static int
BillboardRenderer_init(RendererObject *self, PyObject *args, PyObject *kwargs)
{
	static char *kwlist[] = {"texturizer", NULL};

	self->texturizer = NULL;
	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O:__init__", kwlist,
		&self->texturizer))
		return -1;
	if (self->texturizer == Py_None)
		self->texturizer = NULL; /* Avoid having to test for NULL and None */
	if (self->texturizer != NULL)
		Py_INCREF(self->texturizer);
	return 0;
}

FloatArrayObject *
generate_default_2D_tex_coords(GroupObject *pgroup) {
	static FloatArrayObject *tarray = NULL;
	float *realloc_tcoords, *tex;
	unsigned long pcount, new_size;

	if (tarray == NULL) {
		tarray = PyObject_New(FloatArrayObject, &FloatArray_Type);
		if (tarray == NULL)
			return (FloatArrayObject *)PyErr_NoMemory();
		tarray->size = 0;
		tarray->data = NULL;
	}

	pcount = GroupObject_ActiveCount(pgroup);
	if (tarray->data == NULL || pcount * 8 > tarray->size) {
		new_size = pgroup->plist->palloc * 8;
		realloc_tcoords = PyMem_Realloc(tarray->data, sizeof(float) * new_size);
		if (realloc_tcoords == NULL)
			return (FloatArrayObject *)PyErr_NoMemory();
		tarray->data = realloc_tcoords;
		tex = tarray->data + tarray->size;
		pcount = (new_size - tarray->size) / 8;
		while (pcount--) {
			*tex++ = 0.0f;
			*tex++ = 0.0f;
			*tex++ = 1.0f;
			*tex++ = 0.0f;
			*tex++ = 1.0f;
			*tex++ = 1.0f;
			*tex++ = 0.0f;
			*tex++ = 1.0f;
		}
		tarray->size = new_size;
	}

	Py_INCREF(tarray);
	return tarray;
}

#define MIN_SHORT_INDEX_COUNT 4096
#define MAX_SHORT_INDEX_COUNT 65536

static int
draw_billboards(unsigned long count) {
	int i;
	unsigned short sv = 0;
	static unsigned short *short_indices = NULL;
 	static size_t short_alloc = 0;
	unsigned long index_count;

	index_count = count * 6;
	if (index_count <= MAX_SHORT_INDEX_COUNT) {
		if (index_count > short_alloc) {
			if (short_alloc < MIN_SHORT_INDEX_COUNT)
				short_alloc = MIN_SHORT_INDEX_COUNT;
			while (index_count > short_alloc)
				short_alloc *= 2;
			if (short_indices != NULL)
				PyMem_Free(short_indices);
			short_indices = PyMem_Malloc(short_alloc * sizeof(unsigned short));
			if (short_indices == NULL) {
				PyErr_NoMemory();
				return 0;
			}

			for (i = 0, sv = 0; i <= (short_alloc - 6); i += 6, sv += 4) {
				short_indices[i] = sv;
				short_indices[i+1] = sv+1;
				short_indices[i+2] = sv+3;
				short_indices[i+3] = sv+1;
				short_indices[i+4] = sv+2;
				short_indices[i+5] = sv+3;
			}
		}
		glDrawElements(GL_TRIANGLES, index_count, GL_UNSIGNED_SHORT, short_indices);
	} else {
		/* Too many verts to use an index array of short ints. Instead just
		   draw using GL_QUADS directly and let the driver do the dirty work.
		   Alternately we could use full int indices, but I'd prefer to save
		   the code complexity, bandwidth and memory in this case */
		glDrawArrays(GL_QUADS, 0, count * 4);
	}
	return 1;
}

static PyObject *
BillboardRenderer_draw(RendererObject *self, GroupObject *pgroup)
{
	Particle *p;
	int GL_error;
	unsigned int pcount;
	register unsigned int i;
	float mvmatrix[16], rotcos, rotsin;
	Vec3 vright, vright_unit, vup, vup_unit, vrot;
	long tex_dimension;
	PyObject *r;
	FloatArrayObject *tex_array = NULL;
	VertArray data;

	if (!GroupObject_Check(pgroup)) {
		PyErr_SetString(PyExc_TypeError, "Expected ParticleGroup first argument");
		return NULL;
	}

	if (!glew_initialize())
		return NULL;

	p = pgroup->plist->p;
	pcount = GroupObject_ActiveCount(pgroup);
	if (pcount == 0) {
		Py_INCREF(Py_None);
		return Py_None;
	}
	if (!VertArray_alloc(pgroup, &data))
		return NULL;
	tex_dimension = 2;

	if (self->texturizer != NULL) {
		r = PyObject_GetAttrString(self->texturizer, "tex_dimension");
		if (r == NULL)
			return NULL;
		tex_dimension = PyInt_AsLong(r);
		Py_DECREF(r);
		if (PyErr_Occurred() != NULL)
			return NULL;
		if (tex_dimension < 1 && tex_dimension > 3) {
			PyErr_Format(PyExc_ValueError,
				"Expected texturizer.tex_dimension value of 1, 2 or 3, got %ld", tex_dimension);
			return NULL;
		}
		r = PyObject_CallMethod(self->texturizer, "set_state", NULL);
		if (r == NULL)
			goto error;
		Py_DECREF(r);
	}

	/* Get the alignment vectors from the view matrix */
	glGetFloatv(GL_MODELVIEW_MATRIX, mvmatrix);
	vright_unit.x = mvmatrix[0];
	vright_unit.y = mvmatrix[4];
	vright_unit.z = mvmatrix[8];
	Vec3_normalize(&vright_unit, &vright_unit);
	vup_unit.x = mvmatrix[1];
	vup_unit.y = mvmatrix[5];
	vup_unit.z = mvmatrix[9];
	Vec3_normalize(&vup_unit, &vup_unit);

	glPushClientAttrib(GL_CLIENT_VERTEX_ARRAY_BIT);
	glEnableClientState(GL_TEXTURE_COORD_ARRAY);
	glEnableClientState(GL_VERTEX_ARRAY);
	glEnableClientState(GL_COLOR_ARRAY);
	for (i = 0; i < pcount*4; i += 4) {

#define POINT0 i
#define POINT1 i+1
#define POINT2 i+2
#define POINT3 i+3

		/*

		POINT3                POINT2
			   +-------------+
			   |\            |
			   |  \          |
			   |    \        |
			   |      + ---- | --- Particle position
			   |        \    |
			   |          \  |
			   |            \|
			   +-------------+
		POINT0                POINT1

		*/

		/* vertex coords */

		if (p->up.z) {
			/* billboard supports only z-axis rotation
			   where the z-axiz is always that of the
			   model-view matrix
			*/
			rotsin = (float)sin(p->up.z);
			rotcos = (float)cos(p->up.z);
			Vec3_scalar_mul(&vright, &vright_unit, rotcos);
			Vec3_scalar_mul(&vrot, &vup_unit, rotsin);
			Vec3_addi(&vright, &vrot);
			Vec3_scalar_mul(&vup, &vup_unit, rotcos);
			Vec3_scalar_mul(&vrot, &vright_unit, rotsin);
			Vec3_subi(&vup, &vrot);
			Vec3_scalar_muli(&vright, p->size.x * 0.5f);
			Vec3_scalar_muli(&vup, p->size.y * 0.5f);
		} else {
			Vec3_scalar_mul(&vright, &vright_unit, p->size.x * 0.5f);
			Vec3_scalar_mul(&vup, &vup_unit, p->size.y * 0.5f);
		}

		Vec3_sub(&data.verts[POINT0], &p->position, &vright);
		Vec3_subi(&data.verts[POINT0], &vup);
		Vec3_add(&data.verts[POINT1], &p->position, &vright);
		Vec3_subi(&data.verts[POINT1], &vup);
		Vec3_add(&data.verts[POINT2], &p->position, &vright);
		Vec3_addi(&data.verts[POINT2], &vup);
		Vec3_sub(&data.verts[POINT3], &p->position, &vright);
		Vec3_addi(&data.verts[POINT3], &vup);

		/* colors */
		data.colors[POINT0].rgba.r = (unsigned char)(p->color.r * 255);
		data.colors[POINT0].rgba.g = (unsigned char)(p->color.g * 255);
		data.colors[POINT0].rgba.b = (unsigned char)(p->color.b * 255);
		data.colors[POINT0].rgba.a = (unsigned char)(p->color.a * 255);
		data.colors[POINT1].colorl = data.colors[POINT0].colorl;
		data.colors[POINT2].colorl = data.colors[POINT0].colorl;
		data.colors[POINT3].colorl = data.colors[POINT0].colorl;

		p++;
	}

	if (self->texturizer != NULL) {
		tex_array = (FloatArrayObject *)PyObject_CallMethod(
			self->texturizer, "generate_tex_coords", "O", pgroup);
		if (tex_array == NULL) {
			r = PyObject_CallMethod(self->texturizer, "restore_state", NULL);
			Py_XDECREF(r);
			goto error;
		}
	} else {
		tex_array = generate_default_2D_tex_coords(pgroup);
		if (tex_array == NULL)
			goto error;
	}

	glVertexPointer(3, GL_FLOAT, 0, data.verts);
	glColorPointer(4, GL_UNSIGNED_BYTE, 0, data.colors);
	glTexCoordPointer(tex_dimension, GL_FLOAT, 0, tex_array->data);
	if (!draw_billboards(pcount))
		goto error;
	glPopClientAttrib();

	GL_error = glGetError();
	if (GL_error != GL_NO_ERROR) {
		PyErr_Format(PyExc_RuntimeError, "GL error %d", GL_error);
		goto error;
	}

	if (self->texturizer != NULL) {
		r = PyObject_CallMethod(self->texturizer, "restore_state", NULL);
		if (r == NULL)
			goto error;
		Py_DECREF(r);
	}

	Py_DECREF(tex_array);
	VertArray_free(&data);

	Py_INCREF(Py_None);
	return Py_None;
error:
	Py_XDECREF(tex_array);
	VertArray_free(&data);
	return NULL;
}

static PyMethodDef BillboardRenderer_methods[] = {
	{"draw", (PyCFunction)BillboardRenderer_draw, METH_O,
		PyDoc_STR("Draw the particles using textured billboard quads")},
	{NULL,		NULL}		/* sentinel */
};

static struct PyMemberDef BillboardRenderer_members[] = {
    {"texturizer", T_OBJECT, offsetof(RendererObject, texturizer), 0,
        "A texturizer object that generates texture coordinates\n"
		"for the particles and sets up texture state for the renderer."},
	{NULL}
};

PyDoc_STRVAR(BillboardRenderer__doc__,
	"Particle renderer using textured billboard-aligned quads\n"
	"quads are aligned orthogonal to the model-view matrix\n\n"
	"BillboardRenderer(texturizer=None)\n\n"
	"texturizer -- A texturizer object that generates texture\n"
	"coordinates for the particles and sets up texture state.\n"
	"If not specified, texture coordinates are fixed at (0,0)\n"
	"for the lower-left corner of each particle quad and (1,1)\n"
	"for the upper-right. Without a texturizer the application\n"
	"is responsible for setting up the desired texture state\n"
	"before invoking the renderer.");

static PyTypeObject BillboardRenderer_Type = {
	/* The ob_type field must be initialized in the module init function
	 * to be portable to Windows without using C++. */
	PyObject_HEAD_INIT(NULL)
	0,			/*ob_size*/
	"renderer.BillboardRenderer",		/*tp_name*/
	sizeof(RendererObject),	/*tp_basicsize*/
	0,			/*tp_itemsize*/
	/* methods */
	(destructor)BillboardRenderer_dealloc, /*tp_dealloc*/
	0,			/*tp_print*/
	0,          /*tp_getattr*/
	0,          /*tp_setattr*/
	0,			/*tp_compare*/
	0,			/*tp_repr*/
	0,			/*tp_as_number*/
	0,	        /*tp_as_sequence*/
	0,			/*tp_as_mapping*/
	0,			/*tp_hash*/
	0,                      /*tp_call*/
	0,                      /*tp_str*/
	0,                      /*tp_getattro*/
	0,                      /*tp_setattro*/
	0,                      /*tp_as_buffer*/
	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,     /*tp_flags*/
	BillboardRenderer__doc__,   /*tp_doc*/
	0,                      /*tp_traverse*/
	0,                      /*tp_clear*/
	0,                      /*tp_richcompare*/
	0,                      /*tp_weaklistoffset*/
	0,                      /*tp_iter*/
	0,                      /*tp_iternext*/
	BillboardRenderer_methods,  /*tp_methods*/
	BillboardRenderer_members,  /*tp_members*/
	0,                      /*tp_getset*/
	0,                      /*tp_base*/
	0,                      /*tp_dict*/
	0,                      /*tp_descr_get*/
	0,                      /*tp_descr_set*/
	0,                      /*tp_dictoffset*/
	(initproc)BillboardRenderer_init, /*tp_init*/
	0,                      /*tp_alloc*/
	0,                      /*tp_new*/
	0,                      /*tp_free*/
	0,                      /*tp_is_gc*/
};

PyMODINIT_FUNC
initrenderer(void)
{
	PyObject *m;

	/* Bind external consts here to appease certain compilers */
	PointRenderer_Type.tp_alloc = PyType_GenericAlloc;
	PointRenderer_Type.tp_new = PyType_GenericNew;
	PointRenderer_Type.tp_getattro = PyObject_GenericGetAttr;
	if (PyType_Ready(&PointRenderer_Type) < 0)
		return;

	BillboardRenderer_Type.tp_alloc = PyType_GenericAlloc;
	BillboardRenderer_Type.tp_new = PyType_GenericNew;
	BillboardRenderer_Type.tp_getattro = PyObject_GenericGetAttr;
	if (PyType_Ready(&BillboardRenderer_Type) < 0)
		return;

	/* FloatArray objects cannot be instantiated from Python */
	if (PyType_Ready(&FloatArray_Type) < 0)
		return;

	/* Create the module and add the types */
	m = Py_InitModule3("renderer", NULL, "Particle Renderers");
	if (m == NULL)
		return;

	Py_INCREF(&PointRenderer_Type);
	PyModule_AddObject(m, "PointRenderer", (PyObject *)&PointRenderer_Type);
	Py_INCREF(&BillboardRenderer_Type);
	PyModule_AddObject(m, "BillboardRenderer", (PyObject *)&BillboardRenderer_Type);
}


text:
	var ytapi = require('node-youtubeapi-simplifier');
	ytapi.setup('YOUR API KEY');
	ytapi.searchFunctions.simpleSearch('Search String').then(function (data) {
		console.log(data);
	});
#### Channel Internal Search
##### All (without Limitations - Warning: Can take long!)
	var ytapi = require('node-youtubeapi-simplifier');
	ytapi.setup('YOUR API KEY');
	ytapi.searchFunctions.channelInternalSearch('Youtube Username', 'Search String').then(function (data) {
		console.log(data);
	});
##### Limited to a specified amount (in this case: 10)
	var ytapi = require('node-youtubeapi-simplifier');
	ytapi.setup('YOUR API KEY');
	ytapi.searchFunctions.channelInternalSearch('Youtube Username', 'Search String', 10).then(function (data) {
		console.log(data);
	});


text:
package org.simpleframework.xml;

import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Retention;

/**
 * The ElementMap annotation represents a method or field
 * that is a Map for storing key value pairs. The map
 * object deserialized is typically of the same type as the field.
 * However, a class attribute can be used to override the
 * field type, however the type must be assignable.
 *

 *
 *    <map class="java.util.HashMap">
 *       <entry key="one">value one</entry>
 *       <entry key="two">value two</entry>
 *       <entry key="three">value three</entry>
 *    </map>
 *
 *

 * If a class attribute is not provided and the type or
 * the field or method is abstract, a suitable match is searched for
 * from the maps available from the Java collections framework. This
 * annotation can support both primitive and composite values and
 * keys enabling just about any configuration to be used.
 *

 *
 *    <map class="java.util.HashMap">
 *       <entry key="1">
 *          <value>value one</value>
 *       </entry>
 *       <entry key="2">
 *          <value>value two</value>
 *       </entry>
 *       <entry key="3">
 *          <value>value three</value>
 *       </entry>
 *    </map>
 *
 *

 * The above XML is an example of the output for an composite value
 * object. Composite and primitive values can be used without any
 * specified attributes, in such a case names for primitives are the
 * names of the objects they represent. Also, if desired these
 * default names can be overridden using the provided attributes
 * making the resulting XML entirely configurable.
 *
 * @author Niall Gallagher
 */
@Retention(RetentionPolicy.RUNTIME)
public @interface ElementMap {

   /**
    * This represents the name of the XML element. Annotated fields
    * can optionally provide the name of the element. If no name is
    * provided then the name of the annotated field or method will
    * be used in its place. The name is provided if the field or
    * method name is not suitable as an XML element name. Also, if
    * the list is inline then this must not be specified.
    *
    * @return the name of the XML element this represents
    */
   public String name() default "";

   /**
    * This is used to provide a the name of the entry XML element
    * that wraps the key and value elements. If specified the entry
    * value specified will be used instead of the default name of
    * the element. This is used to ensure the resulting XML is
    * configurable to the requirements of the generated XML.
    *
    * @return this returns the entry XML element for each entry
    */
   public String entry() default "";

   /**
    * This is used to provide a value XML element for each of the
    * values within the map. This essentially wraps the entity to
    * be serialized such that there is an extra XML element present.
    * This can be used to override the default names of primitive
    * values, however it can also be used to wrap composite values.
    *
    * @return this returns the value XML element for each value
    */
   public String value() default "";

   /**
    * This is used to provide a key XML element for each of the
    * keys within the map. This essentially wraps the entity to
    * be serialized such that there is an extra XML element present.
    * This can be used to override the default names of primitive
    * keys, however it can also be used to wrap composite keys.
    *
    * @return this returns the key XML element for each key
    */
   public String key() default "";

   /**
    * Represents the type of key the element map contains. This
    * type is used to deserialize the XML entry key from the map.
    * The object typically represents the deserialized type, but can
    * represent a subclass of the type deserialized as determined
    * by the class attribute value for the map. If
    * this is not specified then the type can be determined from the
    * generic parameter of the annotated Map object.
    *
    * @return the type of the entry key deserialized from the XML
    */
   public Class keyType() default void.class;

   /**
    * Represents the type of value the element map contains. This
    * type is used to deserialize the XML entry value from the map.
    * The object typically represents the deserialized type, but can
    * represent a subclass of the type deserialized as determined
    * by the class attribute value for the map. If
    * this is not specified then the type can be determined from the
    * generic parameter of the annotated Map object.
    *
    * @return the type of the entry value deserialized from the XML
    */
   public Class valueType() default void.class;

   /**
    * Represents whether the key value is to be an attribute or an
    * element. This allows the key to be embedded within the entry
    * XML element allowing for a more compact representation. Only
    * primitive key objects can be represented as an attribute. For
    * example a java.util.Date or a string could be
    * represented as an attribute key for the generated XML.
    *
    * @return true if the key is to be inlined as an attribute
    */
   public boolean attribute() default false;

   /**
    * Determines whether the element is required within the XML
    * document. Any field marked as not required will not have its
    * value set when the object is deserialized. If an object is to
    * be serialized only a null attribute will not appear as XML.
    *
    * @return true if the element is required, false otherwise
    */
   public boolean required() default true;

   /**
    * This is used to determine whether the element data is written
    * in a CDATA block or not. If this is set to true then the text
    * is written within a CDATA block, by default the text is output
    * as escaped XML. Typically this is useful when this annotation
    * is applied to an array of primitives, such as strings.
    *
    * @return true if entries are to be wrapped in a CDATA block
    */
   public boolean data() default false;

   /**
    * Determines whether the element list is inlined with respect
    * to the parent XML element. An inlined element list does not
    * contain an enclosing element. It is simple a sequence of
    * elements that appear one after another within an element.
    * As such an inline element list must not have a name.
    *
    * @return this returns true if the element list is inline
    */
   public boolean inline() default false;

   /**
    * This is used to determine if an optional field or method can
    * remain null if it does not exist. If this is false then the
    * optional element is given an empty map. This is a convenience
    * attribute which avoids having to check if the element is null
    * before providing it with a suitable default instance.
    *
    * @return false if an optional element is always instantiated
    */
   public boolean empty() default true;
}


text:
<!doctype html>

    <meta charset="utf-8"/>
    <meta name="viewport"
          content="width=device-width, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0, user-scalable=no">
    <meta name="apple-mobile-web-app-capable" content="yes">
    <meta name="apple-touch-fullscreen" content="yes">
    <title>KISSY css3 effect</title>

    <link rel="stylesheet" href="../assets/cool.css"/>

    <button id="t2">open dialog with css3 effect</button>


text:
<?php
defined('BASEPATH') OR exit('No direct script access allowed');

class Estados extends CI_Controller {

	public function index()
	{
		$this->load->model('db_model');
		$estado = $this->db_model->obtenerTodoEstados();

		echo json_encode($estado);
	}
}


text:
package org.batfish.vendor.sonic.representation;

import static junit.framework.TestCase.assertFalse;
import static org.batfish.common.matchers.WarningMatchers.hasText;
import static org.batfish.datamodel.Configuration.DEFAULT_VRF_NAME;
import static org.batfish.datamodel.ConfigurationFormat.SONIC;
import static org.batfish.datamodel.acl.AclLineMatchExprs.and;
import static org.batfish.datamodel.acl.AclLineMatchExprs.matchDst;
import static org.batfish.datamodel.acl.AclLineMatchExprs.matchDstPort;
import static org.batfish.datamodel.acl.AclLineMatchExprs.matchIpProtocol;
import static org.batfish.datamodel.acl.AclLineMatchExprs.matchSrc;
import static org.batfish.datamodel.acl.AclLineMatchExprs.matchSrcPort;
import static org.batfish.datamodel.matchers.InterfaceMatchers.hasAccessVlan;
import static org.batfish.datamodel.matchers.InterfaceMatchers.hasAddress;
import static org.batfish.datamodel.matchers.InterfaceMatchers.hasAllowedVlans;
import static org.batfish.datamodel.matchers.InterfaceMatchers.hasDescription;
import static org.batfish.datamodel.matchers.InterfaceMatchers.hasDhcpRelayAddresses;
import static org.batfish.datamodel.matchers.InterfaceMatchers.hasHumanName;
import static org.batfish.datamodel.matchers.InterfaceMatchers.hasInterfaceType;
import static org.batfish.datamodel.matchers.InterfaceMatchers.hasMtu;
import static org.batfish.datamodel.matchers.InterfaceMatchers.hasName;
import static org.batfish.datamodel.matchers.InterfaceMatchers.hasNativeVlan;
import static org.batfish.datamodel.matchers.InterfaceMatchers.hasSpeed;
import static org.batfish.datamodel.matchers.InterfaceMatchers.hasSwitchPortMode;
import static org.batfish.datamodel.matchers.InterfaceMatchers.hasVrfName;
import static org.batfish.representation.frr.FrrConversions.SPEED_CONVERSION_FACTOR;
import static org.batfish.vendor.sonic.representation.SonicConversions.attachAcl;
import static org.batfish.vendor.sonic.representation.SonicConversions.checkVlanId;
import static org.batfish.vendor.sonic.representation.SonicConversions.convertAcls;
import static org.batfish.vendor.sonic.representation.SonicConversions.convertDhcpServers;
import static org.batfish.vendor.sonic.representation.SonicConversions.convertLoopbacks;
import static org.batfish.vendor.sonic.representation.SonicConversions.convertPorts;
import static org.batfish.vendor.sonic.representation.SonicConversions.convertVlans;
import static org.hamcrest.Matchers.allOf;
import static org.hamcrest.Matchers.contains;
import static org.hamcrest.Matchers.containsInAnyOrder;
import static org.hamcrest.Matchers.hasItem;
import static org.hamcrest.Matchers.nullValue;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;

import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Iterables;
import java.util.Map;
import javax.annotation.Nonnull;
import net.sf.javabdd.BDD;
import org.batfish.common.Warnings;
import org.batfish.common.bdd.IpAccessListToBdd;
import org.batfish.datamodel.AclLine;
import org.batfish.datamodel.BddTestbed;
import org.batfish.datamodel.ConcreteInterfaceAddress;
import org.batfish.datamodel.Configuration;
import org.batfish.datamodel.ExprAclLine;
import org.batfish.datamodel.IntegerSpace;
import org.batfish.datamodel.Interface;
import org.batfish.datamodel.InterfaceType;
import org.batfish.datamodel.Ip;
import org.batfish.datamodel.IpAccessList;
import org.batfish.datamodel.IpProtocol;
import org.batfish.datamodel.Prefix;
import org.batfish.datamodel.SwitchportMode;
import org.batfish.datamodel.Vrf;
import org.batfish.vendor.sonic.representation.AclRule.PacketAction;
import org.batfish.vendor.sonic.representation.AclTable.Stage;
import org.batfish.vendor.sonic.representation.AclTable.Type;
import org.batfish.vendor.sonic.representation.SonicConversions.AclRuleWithName;
import org.batfish.vendor.sonic.representation.VlanMember.TaggingMode;
import org.junit.Test;

public class SonicConversionsTest {

  @Test
  public void testConvertPorts() {
    Port port =
        Port.builder()
            .setAdminStatusUp(false)
            .setAlias("alias")
            .setMtu(56)
            .setDescription("desc")
            .setSpeed(23)
            .build();
    String ifaceAddress = "1.1.1.1/24";
    {
      Configuration c =
          Configuration.builder().setHostname("name").setConfigurationFormat(SONIC).build();
      Vrf vrf = Vrf.builder().setName("vrf").setOwner(c).build();
      convertPorts(
          c,
          ImmutableMap.of("iface", port),
          ImmutableMap.of("iface", new L3Interface(ConcreteInterfaceAddress.parse(ifaceAddress))),
          vrf);
      assertThat(
          Iterables.getOnlyElement(c.getAllInterfaces().values()),
          allOf(
              hasName("iface"),
              hasHumanName("alias"),
              hasAddress(ifaceAddress),
              hasMtu(56),
              hasDescription("desc"),
              hasSpeed(23 * SPEED_CONVERSION_FACTOR)));
    }
    {
      // interface does not exist
      Configuration c =
          Configuration.builder().setHostname("name").setConfigurationFormat(SONIC).build();
      Vrf vrf = Vrf.builder().setName("vrf").setOwner(c).build();
      convertPorts(c, ImmutableMap.of("iface", port), ImmutableMap.of(), vrf);
      assertThat(Iterables.getOnlyElement(c.getAllInterfaces().values()).getAddress(), nullValue());
    }
  }

  /**
   * Checks if the Vlan interface is created in the right circumstances and the interactions between
   * data in VLAN and VLAN_INTERFACE.
   */
  @Test
  public void testConvertVlans_vlanInterface() {
    {
      Configuration c =
          Configuration.builder().setHostname("host").setConfigurationFormat(SONIC).build();
      Vrf vrf = Vrf.builder().setOwner(c).setName(DEFAULT_VRF_NAME).build();
      convertVlans(
          c,
          ImmutableMap.of(
              "Vlan1",
              Vlan.builder().setDhcpServers(ImmutableList.of("10.1.1.1")).setVlanId(1).build()),
          ImmutableMap.of(),
          ImmutableMap.of("Vlan1", new L3Interface(ConcreteInterfaceAddress.parse("1.1.1.1/24"))),
          vrf,
          new Warnings());
      assertThat(
          c.getAllInterfaces().get("Vlan1"),
          allOf(
              hasName("Vlan1"),
              hasVrfName(vrf.getName()),
              hasAddress("1.1.1.1/24"),
              hasInterfaceType(InterfaceType.VLAN),
              hasDhcpRelayAddresses(contains(Ip.parse("10.1.1.1")))));
    }
    {
      // no vlan interface
      Configuration c =
          Configuration.builder().setHostname("host").setConfigurationFormat(SONIC).build();
      Vrf vrf = Vrf.builder().setOwner(c).setName(DEFAULT_VRF_NAME).build();
      convertVlans(
          c,
          ImmutableMap.of("Vlan1", Vlan.builder().setVlanId(1).build()),
          ImmutableMap.of(),
          ImmutableMap.of(),
          vrf,
          new Warnings());
      assertNull(c.getAllInterfaces().get("Vlan1"));
    }
    {
      // bad vlanid
      Configuration c =
          Configuration.builder().setHostname("host").setConfigurationFormat(SONIC).build();
      Vrf vrf = Vrf.builder().setOwner(c).setName(DEFAULT_VRF_NAME).build();
      convertVlans(
          c,
          ImmutableMap.of("Vlan1", Vlan.builder().setVlanId(12).build()),
          ImmutableMap.of(),
          ImmutableMap.of("Vlan1", new L3Interface(ConcreteInterfaceAddress.parse("1.1.1.1/24"))),
          vrf,
          new Warnings());
      assertNull(c.getAllInterfaces().get("Vlan1"));
    }
    {
      // vlan exists only in VLAN_INTERFACE
      Configuration c =
          Configuration.builder().setHostname("host").setConfigurationFormat(SONIC).build();
      Vrf vrf = Vrf.builder().setOwner(c).setName(DEFAULT_VRF_NAME).build();
      Warnings warnings = new Warnings(true, true, true);
      convertVlans(
          c,
          ImmutableMap.of(),
          ImmutableMap.of(),
          ImmutableMap.of("Vlan1", new L3Interface(ConcreteInterfaceAddress.parse("1.1.1.1/24"))),
          vrf,
          warnings);
      assertNull(c.getAllInterfaces().get("Vlan1"));
      assertThat(
          warnings.getRedFlagWarnings(),
          contains(
              hasText("Ignoring VLAN_INTERFACEs [Vlan1] because they don't have VLANs defined.")));
    }
  }

  @Test
  public void testConvertVlans_configuredMemberInterfaces() {
    Configuration c =
        Configuration.builder().setHostname("host").setConfigurationFormat(SONIC).build();
    Vrf vrf = Vrf.builder().setOwner(c).setName(DEFAULT_VRF_NAME).build();
    ImmutableList.of("Ethernet0", "Ethernet1")
        .forEach(
            ifaceName ->
                Interface.builder()
                    .setName("Ethernet0")
                    .setOwner(c)
                    .setVrf(vrf)
                    .setType(InterfaceType.PHYSICAL)
                    .build());
    Warnings w = new Warnings(true, true, true);
    convertVlans(
        c,
        ImmutableMap.of(
            "Vlan1",
            Vlan.builder()
                .setVlanId(1)
                .setMembers(ImmutableList.of("Ethernet0", "Ethernet1", "Ethernet2", "Ethernet3"))
                .build()),
        ImmutableMap.of(
            "Vlan1|Ethernet0",
            VlanMember.builder().setTaggingMode(TaggingMode.TAGGED).build(),
            "Vlan1|Ethernet1",
            VlanMember.builder().setTaggingMode(TaggingMode.UNTAGGED).build(),
            "Vlan1|Ethernet2",
            VlanMember.builder().setTaggingMode(TaggingMode.UNTAGGED).build()),
        ImmutableMap.of(),
        vrf,
        w);
    // Ethernet0 already exists in c -- its L2 settings should match 'tagged'
    assertThat(
        c.getAllInterfaces().get("Ethernet0"),
        allOf(
            hasSwitchPortMode(SwitchportMode.TRUNK),
            hasNativeVlan(1),
            hasAllowedVlans(IntegerSpace.of(1))));
    // Ethernet1 already exists in c -- its L2 settings should match 'untagged'
    assertThat(
        c.getAllInterfaces().get("Ethernet1"),
        allOf(hasSwitchPortMode(SwitchportMode.ACCESS), hasAccessVlan(1)));
    // Ethernet2 does not exist in c -- it should have been created with the right L2 settings
    assertThat(
        c.getAllInterfaces().get("Ethernet2"),
        allOf(
            hasName("Ethernet2"),
            hasVrfName(vrf.getName()),
            hasInterfaceType(InterfaceType.PHYSICAL),
            hasSwitchPortMode(SwitchportMode.ACCESS),
            hasAccessVlan(1)));
    // Ethernet3 has no member information -- it should be created and we should get a warning
    assertThat(
        c.getAllInterfaces().get("Ethernet3"),
        allOf(
            hasName("Ethernet3"),
            hasVrfName(vrf.getName()),
            hasSwitchPortMode(SwitchportMode.NONE)));
    assertThat(
        w.getRedFlagWarnings(), hasItem(hasText("Vlan member Vlan1|Ethernet3 is not configured")));
  }

  @Test
  public void testCheckVlanId() {
    assertFalse(checkVlanId("Vlan1", null, new Warnings()));
    assertFalse(checkVlanId("Vlan1", 0, new Warnings()));
    assertFalse(checkVlanId("Vlan1", 4095, new Warnings()));
    assertFalse(checkVlanId("Vlan0", 1, new Warnings()));
    assertFalse(checkVlanId("VlanXX", 1, new Warnings()));
    assertTrue(checkVlanId("Vlan1", 1, new Warnings()));
  }

  @Test
  public void testConvertDhcpServers() {
    {
      Warnings w = new Warnings(true, true, true);
      assertEquals(
          ImmutableList.of(Ip.parse("1.1.1.1"), Ip.parse("1.1.1.2")),
          convertDhcpServers(ImmutableList.of("1.1.1.1", "1.1.1.2"), w));
      assertTrue(w.getRedFlagWarnings().isEmpty());
    }
    {
      Warnings w = new Warnings(true, true, true);
      assertEquals(
          ImmutableList.of(Ip.parse("1.1.1.2")),
          convertDhcpServers(ImmutableList.of("dhcp", "1.1.1.2"), w));
      assertThat(
          w.getRedFlagWarnings(),
          contains(hasText("Cannot add a non-IP address value 'dhcp' as DHCP server")));
    }
  }

  private String ruleKey(String aclName, String ruleName) {
    return String.format("%s|%s", aclName, ruleName);
  }

  private static final BddTestbed _bddTestbed =
      new BddTestbed(ImmutableMap.of(), ImmutableMap.of());
  private static final IpAccessListToBdd _aclToBdd = _bddTestbed.getAclToBdd();

  private static @Nonnull BDD toMatchBDD(AclLine aclLine) {
    return _aclToBdd.toPermitAndDenyBdds(aclLine).getMatchBdd();
  }

  @Test
  public void testConvertAcls() {
    String ifaceName = "Ethernet0";
    Configuration c =
        Configuration.builder().setHostname("host").setConfigurationFormat(SONIC).build();
    Interface.builder().setOwner(c).setName(ifaceName).setType(InterfaceType.PHYSICAL).build();

    String aclName = "testAcl";
    Map<String, AclTable> aclTables =
        ImmutableMap.of(
            aclName,
            AclTable.builder()
                .setPorts(ImmutableList.of(ifaceName))
                .setStage(Stage.INGRESS)
                .setType(Type.L3)
                .build());
    Prefix srcPrefix = Prefix.parse("1.1.1.1/24");
    Prefix dstPrefix = Prefix.parse("2.2.2.2/24");
    Map<String, AclRule> aclRules =
        ImmutableMap.of(
            ruleKey(aclName, "RULE_1"),
            AclRule.builder()
                .setPriority(100) // higher priority
                .setPacketAction(PacketAction.DROP)
                .setSrcIp(srcPrefix.getStartIp().toPrefix())
                .setDstIp(dstPrefix.getStartIp().toPrefix())
                .setL4SrcPort(42424)
                .setL4DstPort(443)
                .setIpProtocol(IpProtocol.TCP.number())
                .build(),
            ruleKey(aclName, "RULE_2"),
            AclRule.builder()
                .setPriority(90)
                .setPacketAction(PacketAction.ACCEPT)
                .setSrcIp(srcPrefix)
                .build());

    convertAcls(c, aclTables, aclRules, new Warnings());

    // ACL exists in the VI model and is attached properly
    IpAccessList ipAccessList = c.getIpAccessLists().get(aclName);
    assertNotNull(ipAccessList);
    assertEquals(aclName, c.getAllInterfaces().get(ifaceName).getIncomingFilter().getName());

    // ACL has all and only the expected rules
    assertEquals(
        ImmutableList.of("RULE_1", "RULE_2"),
        ipAccessList.getLines().stream()
            .map(AclLine::getName)
            .collect(ImmutableList.toImmutableList()));

    assertThat(
        ipAccessList.getLines().stream()
            .map(SonicConversionsTest::toMatchBDD)
            .collect(ImmutableList.toImmutableList()),
        contains(
            toMatchBDD(
                ExprAclLine.rejecting(
                    and(
                        matchIpProtocol(IpProtocol.TCP),
                        matchSrc(srcPrefix.getStartIp()),
                        matchDst(dstPrefix.getStartIp()),
                        matchSrcPort(42424),
                        matchDstPort(443)))),
            toMatchBDD(ExprAclLine.accepting(and(matchSrc(srcPrefix))))));
  }

  @Test
  public void testConvertAcls_badRules() {
    String ifaceName = "Ethernet0";
    Configuration c =
        Configuration.builder().setHostname("host").setConfigurationFormat(SONIC).build();
    Interface.builder().setOwner(c).setName(ifaceName).setType(InterfaceType.PHYSICAL).build();

    String aclName = "testAcl";
    Map<String, AclTable> aclTables =
        ImmutableMap.of(
            aclName,
            AclTable.builder()
                .setPorts(ImmutableList.of(ifaceName))
                .setStage(Stage.INGRESS)
                .setType(Type.L3)
                .build());
    Map<String, AclRule> aclRules =
        ImmutableMap.of(
            "badkey",
            AclRule.builder().setPriority(100).setPacketAction(PacketAction.DROP).build(),
            ruleKey(aclName, "NoPriority"),
            AclRule.builder().setPacketAction(PacketAction.ACCEPT).build(),
            ruleKey(aclName, "NoPacketAction"),
            AclRule.builder().setPriority(100).build(),
            ruleKey("other", "NoAcl"),
            AclRule.builder().setPriority(100).setPacketAction(PacketAction.DROP).build(),
            ruleKey(aclName, "GoodRule"),
            AclRule.builder().setPriority(100).setPacketAction(PacketAction.DROP).build());

    Warnings warnings = new Warnings(true, true, true);
    convertAcls(c, aclTables, aclRules, warnings);

    assertThat(
        warnings.getRedFlagWarnings(),
        containsInAnyOrder(
            hasText("Ignored ACL_RULE badkey: Badly formatted name"),
            hasText("Ignored ACL_RULE testAcl|NoPriority: Missing PRIORITY"),
            hasText("Ignored ACL_RULE testAcl|NoPacketAction: Missing PACKET_ACTION"),
            hasText("Ignored ACL_RULE other|NoAcl: Missing ACL_TABLE 'other'")));

    // ACLs are still converted with whatever is left
    IpAccessList ipAccessList = c.getIpAccessLists().get(aclName);
    assertNotNull(ipAccessList);
    assertEquals(aclName, c.getAllInterfaces().get(ifaceName).getIncomingFilter().getName());
    assertEquals(
        ImmutableList.of("GoodRule"),
        ipAccessList.getLines().stream()
            .map(AclLine::getName)
            .collect(ImmutableList.toImmutableList()));
  }

  @Test
  public void testAclWithRuleNameCompareTo() {
    AclRule.Builder builder = AclRule.builder().setPacketAction(PacketAction.ACCEPT);

    assertTrue(
        new AclRuleWithName("rule1", builder.setPriority(100).build())
                .compareTo(new AclRuleWithName("rule2", builder.setPriority(90).build()))
            < 1);
    assertTrue(
        new AclRuleWithName("rule1", builder.setPriority(100).build())
                .compareTo(new AclRuleWithName("rule2", builder.setPriority(100).build()))
            < 1);
    assertEquals(
        0,
        new AclRuleWithName("rule1", builder.setPriority(100).build())
            .compareTo(new AclRuleWithName("rule1", builder.setPriority(100).build())));
  }

  @Test
  public void testAttachAcl() {
    String ifaceName = "Ethernet0";
    Configuration c =
        Configuration.builder().setHostname("host").setConfigurationFormat(SONIC).build();
    Interface.builder().setOwner(c).setName(ifaceName).setType(InterfaceType.PHYSICAL).build();

    String aclName = "testAcl";
    IpAccessList ipAccessList = IpAccessList.builder().setName(aclName).build();

    {
      // non-L3 ACLs are not attached to interfaces
      AclTable aclTable =
          AclTable.builder()
              .setPorts(ImmutableList.of(ifaceName))
              .setStage(Stage.INGRESS)
              .setType(Type.MIRROR)
              .build();

      Warnings warnings = new Warnings(true, true, true);
      attachAcl(c, aclName, ipAccessList, aclTable, warnings);

      assertTrue(warnings.getRedFlagWarnings().isEmpty());
      assertNull(c.getAllInterfaces().get(ifaceName).getIncomingFilter());
    }
    {
      // missing stage
      AclTable aclTable =
          AclTable.builder().setPorts(ImmutableList.of(ifaceName)).setType(Type.L3).build();

      Warnings warnings = new Warnings(true, true, true);
      attachAcl(c, aclName, ipAccessList, aclTable, warnings);

      assertThat(warnings.getRedFlagWarnings(), contains(hasText("Unimplemented ACL stage: null")));
      assertNull(c.getAllInterfaces().get(ifaceName).getIncomingFilter());
    }
    {
      // one of the ports is missing
      AclTable aclTable =
          AclTable.builder()
              .setPorts(ImmutableList.of(ifaceName, "other", "ctrlplane"))
              .setStage(Stage.EGRESS)
              .setType(Type.L3)
              .build();

      Warnings warnings = new Warnings(true, true, true);
      attachAcl(c, aclName, ipAccessList, aclTable, warnings);

      // warn about 'other', not about 'ctrlplane'
      assertThat(
          warnings.getRedFlagWarnings(),
          contains(hasText("Port 'other' referenced in ACL_TABLE 'testAcl' does not exist.")));
      assertEquals(aclName, c.getAllInterfaces().get(ifaceName).getOutgoingFilter().getName());
    }
  }

  @Test
  public void testConvertLoopbacks() {
    {
      // interface only in LOOPBACK_INTERFACE
      Configuration c =
          Configuration.builder().setHostname("host").setConfigurationFormat(SONIC).build();
      Vrf vrf = Vrf.builder().setOwner(c).setName("vrf").build();
      convertLoopbacks(
          c,
          ImmutableSet.of(),
          ImmutableMap.of(
              "Loopback0", new L3Interface(ConcreteInterfaceAddress.parse("1.1.1.1/24"))),
          vrf);
      assertThat(
          c.getAllInterfaces().get("Loopback0"),
          allOf(
              hasVrfName("vrf"),
              hasInterfaceType(InterfaceType.LOOPBACK),
              hasAddress("1.1.1.1/24")));
    }
    {
      // interface only in LOOPBACK
      Configuration c =
          Configuration.builder().setHostname("host").setConfigurationFormat(SONIC).build();
      Vrf vrf = Vrf.builder().setOwner(c).setName("vrf").build();
      convertLoopbacks(c, ImmutableSet.of("Loopback0"), ImmutableMap.of(), vrf);
      assertThat(
          c.getAllInterfaces().get("Loopback0"),
          allOf(
              hasVrfName("vrf"),
              hasInterfaceType(InterfaceType.LOOPBACK),
              hasAddress(nullValue())));
    }
    {
      // interface in both tables
      Configuration c =
          Configuration.builder().setHostname("host").setConfigurationFormat(SONIC).build();
      Vrf vrf = Vrf.builder().setOwner(c).setName("vrf").build();
      convertLoopbacks(
          c,
          ImmutableSet.of("Loopback0"),
          ImmutableMap.of(
              "Loopback0", new L3Interface(ConcreteInterfaceAddress.parse("1.1.1.1/24"))),
          vrf);
      assertThat(
          c.getAllInterfaces().get("Loopback0"),
          allOf(
              hasVrfName("vrf"),
              hasInterfaceType(InterfaceType.LOOPBACK),
              hasAddress("1.1.1.1/24")));
    }
  }
}


text:
<?php

declare(strict_types=1);

namespace ApiPlatform\JsonSchema;

use ApiPlatform\Api\ResourceClassResolverInterface;
use ApiPlatform\Util\ResourceClassInfoTrait;
use Ramsey\Uuid\UuidInterface;
use Symfony\Component\PropertyInfo\Type;
use Symfony\Component\Uid\Ulid;
use Symfony\Component\Uid\Uuid;

/**
 * {@inheritdoc}
 *
 * @author Kévin Dunglas <dunglas@gmail.com>
 */
final class TypeFactory implements TypeFactoryInterface
{
    use ResourceClassInfoTrait;

    private ?SchemaFactoryInterface $schemaFactory = null;

    public function __construct(ResourceClassResolverInterface $resourceClassResolver = null)
    {
        $this->resourceClassResolver = $resourceClassResolver;
    }

    public function setSchemaFactory(SchemaFactoryInterface $schemaFactory): void
    {
        $this->schemaFactory = $schemaFactory;
    }

    /**
     * {@inheritdoc}
     */
    public function getType(Type $type, string $format = 'json', ?bool $readableLink = null, ?array $serializerContext = null, Schema $schema = null): array
    {
        if ($type->isCollection()) {
            $keyType = $type->getCollectionKeyTypes()[0] ?? null;
            $subType = ($type->getCollectionValueTypes()[0] ?? null) ?? new Type($type->getBuiltinType(), false, $type->getClassName(), false);

            if (null !== $keyType && Type::BUILTIN_TYPE_STRING === $keyType->getBuiltinType()) {
                return $this->addNullabilityToTypeDefinition([
                    'type' => 'object',
                    'additionalProperties' => $this->getType($subType, $format, $readableLink, $serializerContext, $schema),
                ], $type, $schema);
            }

            return $this->addNullabilityToTypeDefinition([
                'type' => 'array',
                'items' => $this->getType($subType, $format, $readableLink, $serializerContext, $schema),
            ], $type, $schema);
        }

        return $this->addNullabilityToTypeDefinition($this->makeBasicType($type, $format, $readableLink, $serializerContext, $schema), $type, $schema);
    }

    private function makeBasicType(Type $type, string $format = 'json', ?bool $readableLink = null, ?array $serializerContext = null, Schema $schema = null): array
    {
        return match ($type->getBuiltinType()) {
            Type::BUILTIN_TYPE_INT => ['type' => 'integer'],
            Type::BUILTIN_TYPE_FLOAT => ['type' => 'number'],
            Type::BUILTIN_TYPE_BOOL => ['type' => 'boolean'],
            Type::BUILTIN_TYPE_OBJECT => $this->getClassType($type->getClassName(), $type->isNullable(), $format, $readableLink, $serializerContext, $schema),
            default => ['type' => 'string'],
        };
    }

    /**
     * Gets the JSON Schema document which specifies the data type corresponding to the given PHP class, and recursively adds needed new schema to the current schema if provided.
     */
    private function getClassType(?string $className, bool $nullable, string $format, ?bool $readableLink, ?array $serializerContext, ?Schema $schema): array
    {
        if (null === $className) {
            return ['type' => 'string'];
        }

        if (is_a($className, \DateTimeInterface::class, true)) {
            return [
                'type' => 'string',
                'format' => 'date-time',
            ];
        }
        if (is_a($className, \DateInterval::class, true)) {
            return [
                'type' => 'string',
                'format' => 'duration',
            ];
        }
        if (is_a($className, UuidInterface::class, true) || is_a($className, Uuid::class, true)) {
            return [
                'type' => 'string',
                'format' => 'uuid',
            ];
        }
        if (is_a($className, Ulid::class, true)) {
            return [
                'type' => 'string',
                'format' => 'ulid',
            ];
        }
        if (is_a($className, \SplFileInfo::class, true)) {
            return [
                'type' => 'string',
                'format' => 'binary',
            ];
        }
        if (is_a($className, \BackedEnum::class, true)) {
            $rEnum = new \ReflectionEnum($className);
            $enumCases = array_map(static fn (\ReflectionEnumBackedCase $rCase) => $rCase->getBackingValue(), $rEnum->getCases());
            if ($nullable) {
                $enumCases[] = null;
            }

            return [
                'type' => (string) $rEnum->getBackingType(),
                'enum' => $enumCases,
            ];
        }

        // Skip if $schema is null (filters only support basic types)
        if (null === $schema) {
            return ['type' => 'string'];
        }

        if (true !== $readableLink && $this->isResourceClass($className)) {
            return [
                'type' => 'string',
                'format' => 'iri-reference',
            ];
        }

        $version = $schema->getVersion();

        $subSchema = new Schema($version);
        $subSchema->setDefinitions($schema->getDefinitions()); // Populate definitions of the main schema

        if (null === $this->schemaFactory) {
            throw new \LogicException('The schema factory must be injected by calling the "setSchemaFactory" method.');
        }

        $subSchema = $this->schemaFactory->buildSchema($className, $format, Schema::TYPE_OUTPUT, null, $subSchema, $serializerContext, false);

        return ['$ref' => $subSchema['$ref']];
    }

    /**
     * @param array<string, mixed> $jsonSchema
     *
     * @return array<string, mixed>
     */
    private function addNullabilityToTypeDefinition(array $jsonSchema, Type $type, ?Schema $schema): array
    {
        if ($schema && Schema::VERSION_SWAGGER === $schema->getVersion()) {
            return $jsonSchema;
        }

        if (!$type->isNullable()) {
            return $jsonSchema;
        }

        if (\array_key_exists('$ref', $jsonSchema)) {
            $typeDefinition = ['anyOf' => [$jsonSchema]];

            if ($schema && Schema::VERSION_JSON_SCHEMA === $schema->getVersion()) {
                $typeDefinition['anyOf'][] = ['type' => 'null'];
            } else {
                // OpenAPI < 3.1
                $typeDefinition['nullable'] = true;
            }

            return $typeDefinition;
        }

        if ($schema && Schema::VERSION_JSON_SCHEMA === $schema->getVersion()) {
            return [...$jsonSchema, ...[
                'type' => \is_array($jsonSchema['type'])
                    ? array_merge($jsonSchema['type'], ['null'])
                    : [$jsonSchema['type'], 'null'],
            ]];
        }

        return [...$jsonSchema, ...['nullable' => true]];
    }
}


text:
void myfree(void* ptr) {

    size_t HEADER_BLK_SIZE = (sizeof(block_header))/4;
    block_header* blk = ptr-(HEADER_BLK_SIZE)*4;
    blk->alloc = 0; // le bloc n'est plus alloué
    block_header* next = blk + (blk->size)/4 + (HEADER_BLK_SIZE);

    if (next->alloc == 0)
      blk->size += next->size + HEADER_BLK_SIZE*4; // si le bloc suivant est vide, on ajoute sa taille à celle de blk

    if (blk != base_heap) { // si blk ne se trouve pas à la base du heap
      block_header* prev = base_heap; // à la fin de la boucle, prev sera le bloc précédent blk
      block_header* curr = prev + (prev->size)/4 + HEADER_BLK_SIZE; // à la fin de la boucle, curr sera égal à blk

      while (curr != blk) {
	prev = curr;
	curr += (curr->size)/4 + HEADER_BLK_SIZE;
      }

      if (prev->alloc == 0)
	prev->size += blk->size + HEADER_BLK_SIZE*4; // si prev est n'est pas alloué, on ajoute la taille de blk à la taille de prev
    }
}


text:
Ti=Prohibition de cession

1.sec=Le présent contrat étant conclu intuitu personae, il ne pourra être cédé ou transféré de quelque manière, à quelque titre et à quelque personne que ce soit sans l'accord express, préalable et écrit, {P1.Handle.du-}.

=[Z/paras/s1]


text:
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.2.4-2
// See http://java.sun.com/xml/jaxb
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2014.08.19 at 01:26:29 PM BRT
//

package br.com.dsfnet.nfse.wsnfe2.tp;

import javax.xml.bind.annotation.XmlEnum;
import javax.xml.bind.annotation.XmlType;

/**
 *
Java class for tpSerieRPS.
 *
 *
The following schema fragment specifies the expected content contained within this class.
 *

 *

 * <simpleType name="tpSerieRPS">
 *   <restriction base="{http://www.w3.org/2001/XMLSchema}string">
 *     <enumeration value="NF"/>
 *   </restriction>
 * </simpleType>
 *

 *
 */
@XmlType(name = "tpSerieRPS")
@XmlEnum
public enum TpSerieRPS {

    /**
     * Nota Fiscal de Servicos
     *
     */
    NF;

    public String value() {
        return name();
    }

    public static TpSerieRPS fromValue(String v) {
        return valueOf(v);
    }

}


text:
layout: default
title: Home
---

  {% for post in paginator.posts %}

        {{ post.title }}

      {{ post.date | date_to_string }}
       - {{ post.categories | array_to_sentence_string }} -
        Comments

    {% assign post_len = post.content | number_of_words %}

    {% if post_len > 100 %}
      {{ post.excerpt }}
    {% else %}
      {{ post.content }}
    {% endif %}

        Tags:
        {{ post.tags | sort | array_to_sentence_string }}

  {% endfor %}

  {% if paginator.next_page %}
    Older
  {% else %}
    Older
  {% endif %}
  {% if paginator.previous_page %}
    {% if paginator.page == 2 %}
      Newer
    {% else %}
      Newer
    {% endif %}
  {% else %}
    Newer
  {% endif %}


text:
package com.google.ads.googleads.v10.errors;

public interface AdGroupErrorEnumOrBuilder extends
    // @@protoc_insertion_point(interface_extends:google.ads.googleads.v10.errors.AdGroupErrorEnum)
    com.google.protobuf.MessageOrBuilder {
}


text:
/* eslint-disable */

'use strict';

/*::
import type { Fragment, ReaderFragment } from 'relay-runtime';
import type { FragmentType } from "relay-runtime";
declare export opaque type FragmentResourceTest2Fragment$fragmentType: FragmentType;
export type FragmentResourceTest2Fragment$data = {|
  +id: string,
  +name: ?string,
  +username: ?string,
  +$fragmentType: FragmentResourceTest2Fragment$fragmentType,
|};
export type FragmentResourceTest2Fragment$key = {
  +$data?: FragmentResourceTest2Fragment$data,
  +$fragmentSpreads: FragmentResourceTest2Fragment$fragmentType,
  ...
};
*/

var node/*: ReaderFragment*/ = {
  "argumentDefinitions": [],
  "kind": "Fragment",
  "metadata": null,
  "name": "FragmentResourceTest2Fragment",
  "selections": [
    {
      "alias": null,
      "args": null,
      "kind": "ScalarField",
      "name": "id",
      "storageKey": null
    },
    {
      "alias": null,
      "args": null,
      "kind": "ScalarField",
      "name": "name",
      "storageKey": null
    },
    {
      "alias": null,
      "args": null,
      "kind": "ScalarField",
      "name": "username",
      "storageKey": null
    }
  ],
  "type": "User",
  "abstractKey": null
};

if (__DEV__) {
  (node/*: any*/).hash = "c6e4e62b113bb7d6ad3334593782d9e2";
}

module.exports = ((node/*: any*/)/*: Fragment<
  FragmentResourceTest2Fragment$fragmentType,
  FragmentResourceTest2Fragment$data,
>*/);


text:
@interface XMPPMessage (XEP_0184)

- (BOOL)hasReceiptRequest;
- (BOOL)hasReceiptResponse;
- (NSString *)extractReceiptResponseID;
- (XMPPMessage *)generateReceiptResponse;

@end