text:
package com.github.kokorin.jaffree.nut;

/**
 * NUT sync point.
 */
@SuppressWarnings({"checkstyle:VisibilityModifier", "checkstyle:MissingJavadocMethod"})
public class SyncPoint {
    /**
     * After a syncpoint, last_pts of each stream is to be set to:
     * last_pts[i] = convert_ts(global_key_pts, time_base[id], time_base[i])
     *

     * global_key_pts MUST be bigger or equal to dts of all past frames across
     * all streams, and smaller or equal to pts of all future frames.
     */
    public final Timestamp globalKeyPts;

    /**
     * back_ptr_div16
     *

     * back_ptr = back_ptr_div16 * 16 + 15
     *

     * back_ptr must point to a position up to 15 bytes before a syncpoint
     * startcode, relative to position of current syncpoint. The syncpoint
     * pointed to MUST be the closest syncpoint such that at least one keyframe
     * with a pts+match_time_delta lower or equal to the current syncpoint's
     * global_key_pts for
     * all streams lies between it and the current syncpoint.
     *

     * A stream where EOR is set is to be ignored for back_ptr.
     */
    public final long backPtrDiv16;

    /**
     * The value of the reference clock at the moment when the first bit of
     * transmit_ts is transmitted/received.
     * The reference clock MUST always be less than or equal to the DTS of
     * every not yet completely received frame.
     */
    public final Timestamp transmitTs;

    public SyncPoint(final Timestamp globalKeyPts, final long backPtrDiv16) {
        this(globalKeyPts, backPtrDiv16, globalKeyPts);
    }

    public SyncPoint(final Timestamp globalKeyPts, final long backPtrDiv16,
                     final Timestamp transmitTs) {
        this.globalKeyPts = globalKeyPts;
        this.backPtrDiv16 = backPtrDiv16;
        this.transmitTs = transmitTs;
    }
}


text:
using System;
using System.Collections.Generic;
using System.Linq;

namespace Resgrid.ApiLoadTester.Helpers
{
	public static class HeaderConverter
	{
		public static List<Tuple<string, string>> ConvertHeaderItems(string header)
		{
			if (String.IsNullOrWhiteSpace(header))
				return null;

			var headers = header.Split(char.Parse(","));

			if (headers != null && headers.Any())
				return headers.Select(item => item.Split(char.Parse("|"))).Select(elements => new Tuple<string, string>(elements[0], elements[1])).ToList();

			return null;
		}
	}
}

redpajama_set_name: RedPajamaGithub


text:
namespace CIK.News.Web.Infras.ActionResults.Admin
{
    using System;
    using System.Data;
    using System.Linq;
    using System.Linq.Expressions;
    using System.Web.Mvc;

    using CIK.News.Entities.NewsAgg;
    using CIK.News.Framework;
    using CIK.News.Framework.Extensions;
    using CIK.News.Web.Infras.ViewModels.Admin.DashBoard;

    public class ItemEditingViewModelActionResult<TController> : ActionResultBase<TController> where TController : Controller
    {
         #region variables & ctors

        private readonly ICategoryRepository _categoryRepository;
        private readonly IItemRepository _itemRepository;

        private readonly int _itemId;

        public ItemEditingViewModelActionResult(
                Expression<Func<TController, ActionResult>> viewNameExpression,
                int itemId)
            : this(viewNameExpression, itemId,
                   DependencyResolver.Current.GetService<ICategoryRepository>(),
                   DependencyResolver.Current.GetService<IItemRepository>())
        {
        }

        public ItemEditingViewModelActionResult(
            Expression<Func<TController, ActionResult>> viewNameExpression,
            int itemId,
            ICategoryRepository categoryRepository,
            IItemRepository itemRepository)
            : base(viewNameExpression)
        {
            this._categoryRepository = categoryRepository;
            this._itemRepository = itemRepository;
            this._itemId = itemId;
        }

        #endregion

        #region implementation

        public override void ExecuteResult(ControllerContext context)
        {
            base.ExecuteResult(context);

            var item = this._itemRepository.GetById(this._itemId);

            if (item == null)
                throw new NoNullAllowedException(string.Format("Item with id={0}", this._itemId).ToNotNullErrorMessage());

            var viewModel = item.MapTo<ItemEditingViewModel>();

            viewModel.Categories = this._categoryRepository.GetCategories().ToList();

            this.GetViewResult(viewModel).ExecuteResult(context);
        }

        public override void EnsureAllInjectInstanceNotNull()
        {
            Guard.ArgumentNotNull(this._categoryRepository, "CategoryRepository");
            Guard.ArgumentNotNull(this._itemRepository, "ItemRepository");
            Guard.ArgumentMustMoreThanZero(this._itemId, "ItemId");
        }

        #endregion
    }
}