hunk.code_window: 		}
   	}
   	posts := &model.PostList{}
   	for _, channel := range channels {
   		if result := <-channel; result.Err != nil {
   			return nil, result.Err
   		} else {
   			data := result.Data.(*model.PostList)
  
hunk.labels: keep keep keep replace keep keep keep keep keep
hunk.after_edit: 	posts := model.NewPostList()
  
hunk.file_path: app/post.go
hunk.type: replace
file: // Copyright 2012 The Go Authors.  All rights reserved.
  // Use of this source code is governed by a BSD-style
  // license that can be found in the LICENSE file.
  
  package windows
  
  import (
  	"syscall"
  	"unsafe"
  )
  
  const (
  	STANDARD_RIGHTS_REQUIRED = 0xf0000
  	STANDARD_RIGHTS_READ     = 0x20000
  	STANDARD_RIGHTS_WRITE    = 0x20000
  	STANDARD_RIGHTS_EXECUTE  = 0x20000
  	STANDARD_RIGHTS_ALL      = 0x1F0000
  )
  
  const (
  	NameUnknown          = 0
  	NameFullyQualifiedDN = 1
  	NameSamCompatible    = 2
  	NameDisplay          = 3
  	NameUniqueId         = 6
  	NameCanonical        = 7
  	NameUserPrincipal    = 8
  	NameCanonicalEx      = 9
  	NameServicePrincipal = 10
  	NameDnsDomain        = 12
  )
  
  // This function returns 1 byte BOOLEAN rather than the 4 byte BOOL.
  // http://blogs.msdn.com/b/drnick/archive/2007/12/19/windows-and-upn-format-credentials.aspx
  //sys	TranslateName(accName *uint16, accNameFormat uint32, desiredNameFormat uint32, translatedName *uint16, nSize *uint32) (err error) [failretval&0xff==0] = secur32.TranslateNameW
  //sys	GetUserNameEx(nameFormat uint32, nameBuffre *uint16, nSize *uint32) (err error) [failretval&0xff==0] = secur32.GetUserNameExW
  
  // TranslateAccountName converts a directory service
  // object name from one format to another.
  func TranslateAccountName(username string, from, to uint32, initSize int) (string, error) {
  	u, e := UTF16PtrFromString(username)
  	if e != nil {
  		return "", e
  	}
  	n := uint32(50)
  	for {
  		b := make([]uint16, n)
  		e = TranslateName(u, from, to, &b[0], &n)
  		if e == nil {
  			return UTF16ToString(b[:n]), nil
  		}
  		if e != ERROR_INSUFFICIENT_BUFFER {
  			return "", e
  		}
  		if n <= uint32(len(b)) {
  			return "", e
  		}
  	}
  }
  
  const (
  	// do not reorder
  	NetSetupUnknownStatus = iota
  	NetSetupUnjoined
  	NetSetupWorkgroupName
  	NetSetupDomainName
  )
  
  type UserInfo10 struct {
  	Name       *uint16
  	Comment    *uint16
  	UsrComment *uint16
  	FullName   *uint16
  }
  
  //sys	NetUserGetInfo(serverName *uint16, userName *uint16, level uint32, buf **byte) (neterr error) = netapi32.NetUserGetInfo
  //sys	NetGetJoinInformation(server *uint16, name **uint16, bufType *uint32) (neterr error) = netapi32.NetGetJoinInformation
  //sys	NetApiBufferFree(buf *byte) (neterr error) = netapi32.NetApiBufferFree
  
  const (
  	// do not reorder
  	SidTypeUser = 1 + iota
  	SidTypeGroup
  	SidTypeDomain
  	SidTypeAlias
  	SidTypeWellKnownGroup
  	SidTypeDeletedAccount
  	SidTypeInvalid
  	SidTypeUnknown
  	SidTypeComputer
  	SidTypeLabel
  )
  
  type SidIdentifierAuthority struct {
  	Value [6]byte
  }
  
  var (
  	SECURITY_NULL_SID_AUTHORITY        = SidIdentifierAuthority{[6]byte{0, 0, 0, 0, 0, 0}}
  	SECURITY_WORLD_SID_AUTHORITY       = SidIdentifierAuthority{[6]byte{0, 0, 0, 0, 0, 1}}
  	SECURITY_LOCAL_SID_AUTHORITY       = SidIdentifierAuthority{[6]byte{0, 0, 0, 0, 0, 2}}
  	SECURITY_CREATOR_SID_AUTHORITY     = SidIdentifierAuthority{[6]byte{0, 0, 0, 0, 0, 3}}
  	SECURITY_NON_UNIQUE_AUTHORITY      = SidIdentifierAuthority{[6]byte{0, 0, 0, 0, 0, 4}}
  	SECURITY_NT_AUTHORITY              = SidIdentifierAuthority{[6]byte{0, 0, 0, 0, 0, 5}}
  	SECURITY_MANDATORY_LABEL_AUTHORITY = SidIdentifierAuthority{[6]byte{0, 0, 0, 0, 0, 16}}
  )
  
  const (
  	SECURITY_NULL_RID                   = 0
  	SECURITY_WORLD_RID                  = 0
  	SECURITY_LOCAL_RID                  = 0
  	SECURITY_CREATOR_OWNER_RID          = 0
  	SECURITY_CREATOR_GROUP_RID          = 1
  	SECURITY_DIALUP_RID                 = 1
  	SECURITY_NETWORK_RID                = 2
  	SECURITY_BATCH_RID                  = 3
  	SECURITY_INTERACTIVE_RID            = 4
  	SECURITY_LOGON_IDS_RID              = 5
  	SECURITY_SERVICE_RID                = 6
  	SECURITY_LOCAL_SYSTEM_RID           = 18
  	SECURITY_BUILTIN_DOMAIN_RID         = 32
  	SECURITY_PRINCIPAL_SELF_RID         = 10
  	SECURITY_CREATOR_OWNER_SERVER_RID   = 0x2
  	SECURITY_CREATOR_GROUP_SERVER_RID   = 0x3
  	SECURITY_LOGON_IDS_RID_COUNT        = 0x3
  	SECURITY_ANONYMOUS_LOGON_RID        = 0x7
  	SECURITY_PROXY_RID                  = 0x8
  	SECURITY_ENTERPRISE_CONTROLLERS_RID = 0x9
  	SECURITY_SERVER_LOGON_RID           = SECURITY_ENTERPRISE_CONTROLLERS_RID
  	SECURITY_AUTHENTICATED_USER_RID     = 0xb
  	SECURITY_RESTRICTED_CODE_RID        = 0xc
  	SECURITY_NT_NON_UNIQUE_RID          = 0x15
  )
  
  //sys	LookupAccountSid(systemName *uint16, sid *SID, name *uint16, nameLen *uint32, refdDomainName *uint16, refdDomainNameLen *uint32, use *uint32) (err error) = advapi32.LookupAccountSidW
  //sys	LookupAccountName(systemName *uint16, accountName *uint16, sid *SID, sidLen *uint32, refdDomainName *uint16, refdDomainNameLen *uint32, use *uint32) (err error) = advapi32.LookupAccountNameW
  //sys	ConvertSidToStringSid(sid *SID, stringSid **uint16) (err error) = advapi32.ConvertSidToStringSidW
  //sys	ConvertStringSidToSid(stringSid *uint16, sid **SID) (err error) = advapi32.ConvertStringSidToSidW
  //sys	GetLengthSid(sid *SID) (len uint32) = advapi32.GetLengthSid
  //sys	CopySid(destSidLen uint32, destSid *SID, srcSid *SID) (err error) = advapi32.CopySid
  //sys	AllocateAndInitializeSid(identAuth *SidIdentifierAuthority, subAuth byte, subAuth0 uint32, subAuth1 uint32, subAuth2 uint32, subAuth3 uint32, subAuth4 uint32, subAuth5 uint32, subAuth6 uint32, subAuth7 uint32, sid **SID) (err error) = advapi32.AllocateAndInitializeSid
  //sys	FreeSid(sid *SID) (err error) [failretval!=0] = advapi32.FreeSid
  //sys	EqualSid(sid1 *SID, sid2 *SID) (isEqual bool) = advapi32.EqualSid
  
  // The security identifier (SID) structure is a variable-length
  // structure used to uniquely identify users or groups.
  type SID struct{}
  
  // StringToSid converts a string-format security identifier
  // sid into a valid, functional sid.
  func StringToSid(s string) (*SID, error) {
  	var sid *SID
  	p, e := UTF16PtrFromString(s)
  	if e != nil {
  		return nil, e
  	}
  	e = ConvertStringSidToSid(p, &sid)
  	if e != nil {
  		return nil, e
  	}
  	defer LocalFree((Handle)(unsafe.Pointer(sid)))
  	return sid.Copy()
  }
  
  // LookupSID retrieves a security identifier sid for the account
  // and the name of the domain on which the account was found.
  // System specify target computer to search.
  func LookupSID(system, account string) (sid *SID, domain string, accType uint32, err error) {
  	if len(account) == 0 {
  		return nil, "", 0, syscall.EINVAL
  	}
  	acc, e := UTF16PtrFromString(account)
  	if e != nil {
  		return nil, "", 0, e
  	}
  	var sys *uint16
  	if len(system) > 0 {
  		sys, e = UTF16PtrFromString(system)
  		if e != nil {
  			return nil, "", 0, e
  		}
  	}
  	n := uint32(50)
  	dn := uint32(50)
  	for {
  		b := make([]byte, n)
  		db := make([]uint16, dn)
  		sid = (*SID)(unsafe.Pointer(&b[0]))
  		e = LookupAccountName(sys, acc, sid, &n, &db[0], &dn, &accType)
  		if e == nil {
  			return sid, UTF16ToString(db), accType, nil
  		}
  		if e != ERROR_INSUFFICIENT_BUFFER {
  			return nil, "", 0, e
  		}
  		if n <= uint32(len(b)) {
  			return nil, "", 0, e
  		}
  	}
  }
  
  // String converts sid to a string format
  // suitable for display, storage, or transmission.
  func (sid *SID) String() (string, error) {
  	var s *uint16
  	e := ConvertSidToStringSid(sid, &s)
  	if e != nil {
  		return "", e
  	}
  	defer LocalFree((Handle)(unsafe.Pointer(s)))
  	return UTF16ToString((*[256]uint16)(unsafe.Pointer(s))[:]), nil
  }
  
  // Len returns the length, in bytes, of a valid security identifier sid.
  func (sid *SID) Len() int {
  	return int(GetLengthSid(sid))
  }
  
  // Copy creates a duplicate of security identifier sid.
  func (sid *SID) Copy() (*SID, error) {
  	b := make([]byte, sid.Len())
  	sid2 := (*SID)(unsafe.Pointer(&b[0]))
  	e := CopySid(uint32(len(b)), sid2, sid)
  	if e != nil {
  		return nil, e
  	}
  	return sid2, nil
  }
  
  // LookupAccount retrieves the name of the account for this sid
  // and the name of the first domain on which this sid is found.
  // System specify target computer to search for.
  func (sid *SID) LookupAccount(system string) (account, domain string, accType uint32, err error) {
  	var sys *uint16
  	if len(system) > 0 {
  		sys, err = UTF16PtrFromString(system)
  		if err != nil {
  			return "", "", 0, err
  		}
  	}
  	n := uint32(50)
  	dn := uint32(50)
  	for {
  		b := make([]uint16, n)
  		db := make([]uint16, dn)
  		e := LookupAccountSid(sys, sid, &b[0], &n, &db[0], &dn, &accType)
  		if e == nil {
  			return UTF16ToString(b), UTF16ToString(db), accType, nil
  		}
  		if e != ERROR_INSUFFICIENT_BUFFER {
  			return "", "", 0, e
  		}
  		if n <= uint32(len(b)) {
  			return "", "", 0, e
  		}
  	}
  }
  
  const (
  	// do not reorder
  	TOKEN_ASSIGN_PRIMARY = 1 << iota
  	TOKEN_DUPLICATE
  	TOKEN_IMPERSONATE
  	TOKEN_QUERY
  	TOKEN_QUERY_SOURCE
  	TOKEN_ADJUST_PRIVILEGES
  	TOKEN_ADJUST_GROUPS
  	TOKEN_ADJUST_DEFAULT
  
  	TOKEN_ALL_ACCESS = STANDARD_RIGHTS_REQUIRED |
  		TOKEN_ASSIGN_PRIMARY |
  		TOKEN_DUPLICATE |
  		TOKEN_IMPERSONATE |
  		TOKEN_QUERY |
  		TOKEN_QUERY_SOURCE |
  		TOKEN_ADJUST_PRIVILEGES |
  		TOKEN_ADJUST_GROUPS |
  		TOKEN_ADJUST_DEFAULT
  	TOKEN_READ  = STANDARD_RIGHTS_READ | TOKEN_QUERY
  	TOKEN_WRITE = STANDARD_RIGHTS_WRITE |
  		TOKEN_ADJUST_PRIVILEGES |
  		TOKEN_ADJUST_GROUPS |
  		TOKEN_ADJUST_DEFAULT
  	TOKEN_EXECUTE = STANDARD_RIGHTS_EXECUTE
  )
  
  const (
  	// do not reorder
  	TokenUser = 1 + iota
  	TokenGroups
  	TokenPrivileges
  	TokenOwner
  	TokenPrimaryGroup
  	TokenDefaultDacl
  	TokenSource
  	TokenType
  	TokenImpersonationLevel
  	TokenStatistics
  	TokenRestrictedSids
  	TokenSessionId
  	TokenGroupsAndPrivileges
  	TokenSessionReference
  	TokenSandBoxInert
  	TokenAuditPolicy
  	TokenOrigin
  	TokenElevationType
  	TokenLinkedToken
  	TokenElevation
  	TokenHasRestrictions
  	TokenAccessInformation
  	TokenVirtualizationAllowed
  	TokenVirtualizationEnabled
  	TokenIntegrityLevel
  	TokenUIAccess
  	TokenMandatoryPolicy
  	TokenLogonSid
  	MaxTokenInfoClass
  )
  
  type SIDAndAttributes struct {
  	Sid        *SID
  	Attributes uint32
  }
  
  type Tokenuser struct {
  	User SIDAndAttributes
  }
  
  type Tokenprimarygroup struct {
  	PrimaryGroup *SID
  }
  
  type Tokengroups struct {
  	GroupCount uint32
  	Groups     [1]SIDAndAttributes
  }
  
  //sys	OpenProcessToken(h Handle, access uint32, token *Token) (err error) = advapi32.OpenProcessToken
  //sys	GetTokenInformation(t Token, infoClass uint32, info *byte, infoLen uint32, returnedLen *uint32) (err error) = advapi32.GetTokenInformation
  //sys	GetUserProfileDirectory(t Token, dir *uint16, dirLen *uint32) (err error) = userenv.GetUserProfileDirectoryW
  
  // An access token contains the security information for a logon session.
  // The system creates an access token when a user logs on, and every
  // process executed on behalf of the user has a copy of the token.
  // The token identifies the user, the user's groups, and the user's
  // privileges. The system uses the token to control access to securable
  // objects and to control the ability of the user to perform various
  // system-related operations on the local computer.
  type Token Handle
  
  // OpenCurrentProcessToken opens the access token
  // associated with current process.
  func OpenCurrentProcessToken() (Token, error) {
  	p, e := GetCurrentProcess()
  	if e != nil {
  		return 0, e
  	}
  	var t Token
  	e = OpenProcessToken(p, TOKEN_QUERY, &t)
  	if e != nil {
  		return 0, e
  	}
  	return t, nil
  }
  
  // Close releases access to access token.
  func (t Token) Close() error {
  	return CloseHandle(Handle(t))
  }
  
  // getInfo retrieves a specified type of information about an access token.
  func (t Token) getInfo(class uint32, initSize int) (unsafe.Pointer, error) {
  	n := uint32(initSize)
  	for {
  		b := make([]byte, n)
  		e := GetTokenInformation(t, class, &b[0], uint32(len(b)), &n)
  		if e == nil {
  			return unsafe.Pointer(&b[0]), nil
  		}
  		if e != ERROR_INSUFFICIENT_BUFFER {
  			return nil, e
  		}
  		if n <= uint32(len(b)) {
  			return nil, e
  		}
  	}
  }
  
  // GetTokenUser retrieves access token t user account information.
  func (t Token) GetTokenUser() (*Tokenuser, error) {
  	i, e := t.getInfo(TokenUser, 50)
  	if e != nil {
  		return nil, e
  	}
  	return (*Tokenuser)(i), nil
  }
  
  // GetTokenGroups retrieves group accounts associated with access token t.
  func (t Token) GetTokenGroups() (*Tokengroups, error) {
  	i, e := t.getInfo(TokenGroups, 50)
  	if e != nil {
  		return nil, e
  	}
  	return (*Tokengroups)(i), nil
  }
  
  // GetTokenPrimaryGroup retrieves access token t primary group information.
  // A pointer to a SID structure representing a group that will become
  // the primary group of any objects created by a process using this access token.
  func (t Token) GetTokenPrimaryGroup() (*Tokenprimarygroup, error) {
  	i, e := t.getInfo(TokenPrimaryGroup, 50)
  	if e != nil {
  		return nil, e
  	}
  	return (*Tokenprimarygroup)(i), nil
  }
  
  // GetUserProfileDirectory retrieves path to the
  // root directory of the access token t user's profile.
  func (t Token) GetUserProfileDirectory() (string, error) {
  	n := uint32(100)
  	for {
  		b := make([]uint16, n)
  		e := GetUserProfileDirectory(t, &b[0], &n)
  		if e == nil {
  			return UTF16ToString(b), nil
  		}
  		if e != ERROR_INSUFFICIENT_BUFFER {
  			return "", e
  		}
  		if n <= uint32(len(b)) {
  			return "", e
  		}
  	}
  }
  