/brz/remove-bazaar : revision 0.239.10

1

2

3

#

4

# This program is free software; you can redistribute it and/or modify

5

# it under the terms of the GNU General Public License as published by

35

from bzrlib.decorators import (

36

needs_read_lock,

37

)

38

from bzrlib.revision import (

39

NULL_REVISION,

40

)

41

38

from bzrlib.trace import (

42

39

is_quiet,

43

40

mutter,

44

41

)

45

42

43

from bzrlib.plugins.git import (

44

get_rich_root_format,

45

)

46

from bzrlib.plugins.git.config import (

47

GitBranchConfig,

48

)

50

NoPushSupport,

51

NoSuchRef,

52

)

53

from bzrlib.plugins.git.refs import (

54

ref_to_branch_name,

55

extract_tags,

56

tag_name_to_ref,

57

)

58

53

59

54

from bzrlib.foreign import ForeignBranch

60

55

61

56

57

def extract_tags(refs, mapping):

58

ret = {}

59

for k,v in refs.iteritems():

60

if k.startswith("refs/tags/") and not k.endswith("^{}"):

61

v = refs.get(k+"^{}", v)

62

ret[k[len("refs/tags/"):]] = mapping.revision_id_foreign_to_bzr(v)

63

return ret

64

65

62

66

class GitPullResult(branch.PullResult):

63

"""Result of a pull from a Git branch."""

64

67

65

68

def _lookup_revno(self, revid):

66

69

assert isinstance(revid, str), "was %r" % revid

85

88

86

89

def get_tag_dict(self):

87

90

ret = {}

88

for k,v in extract_tags(self.repository._git.get_refs()).iteritems():

89

try:

90

obj = self.repository._git[v]

91

except KeyError:

92

mutter("Tag %s points at unknown object %s, ignoring", v, obj)

93

continue

91

for k,v in self.repository._git.refs.as_dict("refs/tags").iteritems():

92

obj = self.repository._git.get_object(v)

94

93

while isinstance(obj, Tag):

95

94

v = obj.object[1]

96

obj = self.repository._git[v]

95

obj = self.repository._git.get_object(v)

97

96

if not isinstance(obj, Commit):

98

97

mutter("Tag %s points at object %r that is not a commit, "

99

98

"ignoring", k, obj)

100

99

continue

101

ret[k] = self.branch.lookup_foreign_revision_id(v)

100

ret[k] = self.branch.mapping.revision_id_foreign_to_bzr(v)

102

101

return ret

103

102

104

def _set_tag_dict(self, to_dict):

105

extra = set(self.repository._git.get_refs().keys())

106

for k, revid in to_dict.iteritems():

107

name = tag_name_to_ref(k)

108

if name in extra:

109

extra.remove(name)

110

self.set_tag(k, revid)

111

for name in extra:

112

if name.startswith("refs/tags/"):

113

del self.repository._git[name]

114

115

103

def set_tag(self, name, revid):

116

self.repository._git.refs[tag_name_to_ref(name)], _ = \

104

self.repository._git.refs["refs/tags/%s" % name], _ = \

117

105

self.branch.mapping.revision_id_bzr_to_foreign(revid)

118

106

119

107

120

108

class DictTagDict(LocalGitTagDict):

121

109

110

122

111

def __init__(self, branch, tags):

123

112

super(DictTagDict, self).__init__(branch)

124

113

self._tags = tags

127

116

return self._tags

128

117

129

118

119

130

120

class GitBranchFormat(branch.BranchFormat):

131

121

132

122

def get_format_description(self):

133

123

return 'Git Branch'

134

124

135

def network_name(self):

136

return "git"

137

138

125

def supports_tags(self):

139

126

return True

140

127

141

def get_foreign_tests_branch_factory(self):

142

from bzrlib.plugins.git.tests.test_branch import ForeignTestsBranchFactory

143

return ForeignTestsBranchFactory()

144

145

128

def make_tags(self, branch):

146

129

if getattr(branch.repository, "get_refs", None) is not None:

147

130

from bzrlib.plugins.git.remote import RemoteGitTagDict

150

133

return LocalGitTagDict(branch)

151

134

152

135

153

class GitReadLock(object):

154

155

def __init__(self, unlock):

156

self.unlock = unlock

157

158

159

class GitWriteLock(object):

160

161

def __init__(self, unlock):

162

self.unlock = unlock

163

164

165

136

class GitBranch(ForeignBranch):

166

137

"""An adapter to git repositories for bzr Branch objects."""

167

138

168

def __init__(self, bzrdir, repository, ref, lockfiles, tagsdict=None):

139

def __init__(self, bzrdir, repository, name, lockfiles, tagsdict=None):

169

140

self.repository = repository

170

141

self._format = GitBranchFormat()

171

142

self.control_files = lockfiles

173

144

super(GitBranch, self).__init__(repository.get_mapping())

174

145

if tagsdict is not None:

175

146

self.tags = DictTagDict(self, tagsdict)

176

self.ref = ref

177

self.name = ref_to_branch_name(ref)

147

self.name = name

178

148

self._head = None

179

self.base = bzrdir.root_transport.base

149

self.base = bzrdir.transport.base

180

150

181

151

def _get_checkout_format(self):

182

152

"""Return the most suitable metadir for a checkout of this branch.

183

153

Weaves are used if this branch's repository uses weaves.

184

154

"""

185

return bzrdir.format_registry.make_bzrdir("default")

155

return get_rich_root_format()

186

156

187

157

def get_child_submit_format(self):

188

158

"""Return the preferred format of submissions to this branch."""

196

166

197

167

:return: Branch nick

198

168

"""

199

return self.name or "HEAD"

169

return self.name

200

170

201

171

def _set_nick(self, nick):

202

172

raise NotImplementedError

204

174

nick = property(_get_nick, _set_nick)

205

175

206

176

def __repr__(self):

207

return "<%s(%r, %r)>" % (self.__class__.__name__, self.repository.base,

208

self.ref or "HEAD")

177

return "%s(%r, %r)" % (self.__class__.__name__, self.repository.base, self.name)

209

178

210

179

def generate_revision_history(self, revid, old_revid=None):

211

180

# FIXME: Check that old_revid is in the ancestry of revid

214

183

215

184

def lock_write(self):

216

185

self.control_files.lock_write()

217

return GitWriteLock(self.unlock)

218

186

219

187

def get_stacked_on_url(self):

220

188

# Git doesn't do stacking (yet...)

221

raise errors.UnstackableBranchFormat(self._format, self.base)

189

return None

222

190

223

191

def get_parent(self):

224

192

"""See Branch.get_parent()."""

231

199

232

200

def lock_read(self):

233

201

self.control_files.lock_read()

234

return GitReadLock(self.unlock)

235

202

236

203

def is_locked(self):

237

204

return self.control_files.is_locked()

247

214

# perhaps should escape this ?

248

215

if self.head is None:

249

216

return revision.NULL_REVISION

250

return self.lookup_foreign_revision_id(self.head)

217

return self.mapping.revision_id_foreign_to_bzr(self.head)

251

218

252

219

def _basic_push(self, target, overwrite=False, stop_revision=None):

253

220

return branch.InterBranch.get(self, target)._basic_push(

254

221

overwrite, stop_revision)

255

222

256

def lookup_foreign_revision_id(self, foreign_revid):

257

return self.repository.lookup_foreign_revision_id(foreign_revid,

258

self.mapping)

259

260

223

261

224

class LocalGitBranch(GitBranch):

262

225

"""A local Git branch."""

263

226

264

def __init__(self, bzrdir, repository, name, lockfiles, tagsdict=None):

265

super(LocalGitBranch, self).__init__(bzrdir, repository, name,

266

lockfiles, tagsdict)

267

refs = repository._git.get_refs()

268

if not (name in refs.keys() or "HEAD" in refs.keys()):

269

raise errors.NotBranchError(self.base)

270

271

227

def create_checkout(self, to_location, revision_id=None, lightweight=False,

272

228

accelerator_tree=None, hardlink=False):

273

229

if lightweight:

275

231

t.ensure_base()

276

232

format = self._get_checkout_format()

277

233

checkout = format.initialize_on_transport(t)

278

from_branch = branch.BranchReferenceFormat().initialize(checkout,

234

from_branch = branch.BranchReferenceFormat().initialize(checkout,

279

235

self)

280

236

tree = checkout.create_workingtree(revision_id,

281

237

from_branch=from_branch, hardlink=hardlink)

282

238

return tree

283

239

else:

284

240

return self._create_heavyweight_checkout(to_location, revision_id,

285

hardlink)

241

hardlink)

286

242

287

def _create_heavyweight_checkout(self, to_location, revision_id=None,

243

def _create_heavyweight_checkout(self, to_location, revision_id=None,

288

244

hardlink=False):

289

245

"""Create a new heavyweight checkout of this branch.

290

246

294

250

:return: WorkingTree object of checkout.

295

251

"""

296

252

checkout_branch = bzrdir.BzrDir.create_branch_convenience(

297

to_location, force_new_tree=False)

253

to_location, force_new_tree=False, format=get_rich_root_format())

298

254

checkout = checkout_branch.bzrdir

299

255

checkout_branch.bind(self)

300

# pull up to the specified revision_id to set the initial

256

# pull up to the specified revision_id to set the initial

301

257

# branch tip correctly, and seed it with history.

302

258

checkout_branch.pull(self, stop_revision=revision_id)

303

259

return checkout.create_workingtree(revision_id, hardlink=hardlink)

312

268

313

269

def _get_head(self):

314

270

try:

315

return self.repository._git.ref(self.ref or "HEAD")

271

return self.repository._git.ref(self.name)

316

272

except KeyError:

317

273

return None

318

274

320

276

self.set_last_revision(revid)

321

277

322

278

def set_last_revision(self, revid):

323

(newhead, self.mapping) = self.repository.lookup_bzr_revision_id(revid)

279

(newhead, self.mapping) = self.mapping.revision_id_bzr_to_foreign(

280

revid)

324

281

self.head = newhead

325

282

326

283

def _set_head(self, value):

327

284

self._head = value

328

self.repository._git.refs[self.ref or "HEAD"] = self._head

285

self.repository._git.refs[self.name] = self._head

329

286

self._clear_cached_state()

330

287

331

288

head = property(_get_head, _set_head)

349

306

350

307

class GitBranchPullResult(branch.PullResult):

351

308

352

def __init__(self):

353

super(GitBranchPullResult, self).__init__()

354

self.new_git_head = None

355

self._old_revno = None

356

self._new_revno = None

357

358

309

def report(self, to_file):

359

310

if not is_quiet():

360

311

if self.old_revid == self.new_revid:

361

312

to_file.write('No revisions to pull.\n')

362

elif self.new_git_head is not None:

363

to_file.write('Now on revision %d (git sha: %s).\n' %

313

else:

314

to_file.write('Now on revision %d (git sha: %s).\n' %

364

315

(self.new_revno, self.new_git_head))

365

else:

366

to_file.write('Now on revision %d.\n' % (self.new_revno,))

367

316

self._show_tag_conficts(to_file)

368

317

369

def _lookup_revno(self, revid):

370

assert isinstance(revid, str), "was %r" % revid

371

# Try in source branch first, it'll be faster

372

try:

373

return self.source_branch.revision_id_to_revno(revid)

374

except errors.NoSuchRevision:

375

# FIXME: Check using graph.find_distance_to_null() ?

376

return self.target_branch.revision_id_to_revno(revid)

377

378

def _get_old_revno(self):

379

if self._old_revno is not None:

380

return self._old_revno

381

return self._lookup_revno(self.old_revid)

382

383

def _set_old_revno(self, revno):

384

self._old_revno = revno

385

386

old_revno = property(_get_old_revno, _set_old_revno)

387

388

def _get_new_revno(self):

389

if self._new_revno is not None:

390

return self._new_revno

391

return self._lookup_revno(self.new_revid)

392

393

def _set_new_revno(self, revno):

394

self._new_revno = revno

395

396

new_revno = property(_get_new_revno, _set_new_revno)

397

398

318

399

319

class GitBranchPushResult(branch.BranchPushResult):

400

320

420

340

"""InterBranch implementation that pulls from Git into bzr."""

421

341

422

342

@classmethod

423

def _get_interrepo(self, source, target):

424

return repository.InterRepository.get(source.repository,

425

target.repository)

426

427

@classmethod

428

def is_compatible(cls, source, target):

429

return (isinstance(source, GitBranch) and

430

not isinstance(target, GitBranch) and

431

(getattr(cls._get_interrepo(source, target), "fetch_objects", None) is not None))

432

433

def _update_revisions(self, stop_revision=None, overwrite=False,

434

graph=None, limit=None):

435

"""Like InterBranch.update_revisions(), but with additions.

436

437

Compared to the `update_revisions()` below, this function takes a

438

`limit` argument that limits how many git commits will be converted

439

and returns the new git head.

440

"""

441

interrepo = self._get_interrepo(self.source, self.target)

343

def is_compatible(self, source, target):

344

return (isinstance(source, GitBranch) and

345

not isinstance(target, GitBranch))

346

347

def update_revisions(self, stop_revision=None, overwrite=False,

348

graph=None):

349

"""See InterBranch.update_revisions()."""

350

interrepo = repository.InterRepository.get(self.source.repository,

351

self.target.repository)

352

self._head = None

353

self._last_revid = None

442

354

def determine_wants(heads):

443

if self.source.ref is not None and not self.source.ref in heads:

444

raise NoSuchRef(self.source.ref, heads.keys())

355

if not self.source.name in heads:

356

raise NoSuchRef(self.source.name, heads.keys())

445

357

if stop_revision is not None:

446

358

self._last_revid = stop_revision

447

head, mapping = self.source.repository.lookup_bzr_revision_id(

359

self._head, mapping = self.source.repository.lookup_git_revid(

448

360

stop_revision)

449

361

else:

450

if self.source.ref is not None:

451

head = heads[self.source.ref]

452

else:

453

head = heads["HEAD"]

454

self._last_revid = self.source.lookup_foreign_revision_id(head)

362

self._head = heads[self.source.name]

363

self._last_revid = \

364

self.source.mapping.revision_id_foreign_to_bzr(self._head)

455

365

if self.target.repository.has_revision(self._last_revid):

456

366

return []

457

return [head]

458

pack_hint, head = interrepo.fetch_objects(

459

determine_wants, self.source.mapping, limit=limit)

460

if (pack_hint is not None and

461

self.target.repository._format.pack_compresses):

462

self.target.repository.pack(hint=pack_hint)

463

if head is not None:

464

self._last_revid = self.source.lookup_foreign_revision_id(head)

367

return [self._head]

368

interrepo.fetch_objects(determine_wants, self.source.mapping)

465

369

if overwrite:

466

370

prev_last_revid = None

467

371

else:

468

372

prev_last_revid = self.target.last_revision()

469

self.target.generate_revision_history(self._last_revid,

470

prev_last_revid)

471

return head

472

473

def update_revisions(self, stop_revision=None, overwrite=False,

474

graph=None):

475

"""See InterBranch.update_revisions()."""

476

self._update_revisions(stop_revision, overwrite, graph)

373

self.target.generate_revision_history(self._last_revid, prev_last_revid)

477

374

478

375

def pull(self, overwrite=False, stop_revision=None,

479

376

possible_transports=None, _hook_master=None, run_hooks=True,

480

_override_hook_target=None, local=False, limit=None):

377

_override_hook_target=None, local=False):

481

378

"""See Branch.pull.

482

379

483

380

:param _hook_master: Private parameter - set the branch to

487

384

so it should not run its hooks.

488

385

:param _override_hook_target: Private parameter - set the branch to be

489

386

supplied as the target_branch to pull hooks.

490

:param limit: Only import this many revisons. `None`, the default,

491

means import all revisions.

492

387

"""

493

388

# This type of branch can't be bound.

494

389

if local:

504

399

# We assume that during 'pull' the target repository is closer than

505

400

# the source one.

506

401

graph = self.target.repository.get_graph(self.source.repository)

507

(result.old_revno, result.old_revid) = \

402

result.old_revno, result.old_revid = \

508

403

self.target.last_revision_info()

509

result.new_git_head = self._update_revisions(

510

stop_revision, overwrite=overwrite, graph=graph, limit=limit)

404

self.update_revisions(stop_revision, overwrite=overwrite,

405

graph=graph)

406

result.new_git_head = self._head

511

407

result.tag_conflicts = self.source.tags.merge_to(self.target.tags,

512

408

overwrite)

513

(result.new_revno, result.new_revid) = \

514

self.target.last_revision_info()

409

result.new_revno, result.new_revid = self.target.last_revision_info()

515

410

if _hook_master:

516

411

result.master_branch = _hook_master

517

412

result.local_branch = result.target_branch

531

426

result.target_branch = self.target

532

427

graph = self.target.repository.get_graph(self.source.repository)

533

428

result.old_revno, result.old_revid = self.target.last_revision_info()

534

result.new_git_head = self._update_revisions(

535

stop_revision, overwrite=overwrite, graph=graph)

429

self.update_revisions(stop_revision, overwrite=overwrite,

430

graph=graph)

431

result.new_git_head = self._head

536

432

result.tag_conflicts = self.source.tags.merge_to(self.target.tags,

537

433

overwrite)

538

434

result.new_revno, result.new_revid = self.target.last_revision_info()

549

445

@classmethod

550

446

def is_compatible(self, source, target):

551

447

from bzrlib.plugins.git.remote import RemoteGitBranch

552

return (isinstance(source, LocalGitBranch) and

448

return (isinstance(source, LocalGitBranch) and

553

449

isinstance(target, RemoteGitBranch))

554

450

555

451

def _basic_push(self, overwrite=False, stop_revision=None):

556

from dulwich.protocol import ZERO_SHA

557

452

result = GitBranchPushResult()

558

453

result.source_branch = self.source

559

454

result.target_branch = self.target

561

456

stop_revision = self.source.last_revision()

562

457

# FIXME: Check for diverged branches

563

458

def get_changed_refs(old_refs):

564

result.old_revid = self.target.lookup_foreign_revision_id(old_refs.get(self.target.ref, ZERO_SHA))

565

refs = { self.target.ref: self.source.repository.lookup_bzr_revision_id(stop_revision)[0] }

459

result.old_revid = self.target.mapping.revision_id_foreign_to_bzr(old_refs.get("refs/heads/master", "0" * 40))

460

refs = { "refs/heads/master": self.source.repository.lookup_git_revid(stop_revision)[0] }

566

461

result.new_revid = stop_revision

567

462

for name, sha in self.source.repository._git.refs.as_dict("refs/tags").iteritems():

568

refs[tag_name_to_ref(name)] = sha

463

refs["refs/tags/%s" % name] = sha

569

464

return refs

570

self.target.repository.send_pack(get_changed_refs,

571

self.source.repository._git.object_store.generate_pack_contents)

465

self.target.repository.send_pack(get_changed_refs,

466

self.source.repository._git.object_store.generate_pack_contents)

572

467

return result

573

468

574

469

578

473

@classmethod

579

474

def is_compatible(self, source, target):

580

475

from bzrlib.plugins.git.remote import RemoteGitBranch

581

return (isinstance(source, RemoteGitBranch) and

476

return (isinstance(source, RemoteGitBranch) and

582

477

isinstance(target, LocalGitBranch))

583

478

584

479

def _basic_push(self, overwrite=False, stop_revision=None):

593

488

return result

594

489

595

490

def update_tags(self, refs):

596

for name, v in extract_tags(refs).iteritems():

597

revid = self.target.lookup_foreign_revision_id(v)

491

for name, revid in extract_tags(refs, self.target.mapping).iteritems():

598

492

self.target.tags.set_tag(name, revid)

599

493

600

494

def update_refs(self, stop_revision=None):

601

interrepo = repository.InterRepository.get(self.source.repository,

495

interrepo = repository.InterRepository.get(self.source.repository,

602

496

self.target.repository)

603

497

if stop_revision is None:

604

refs = interrepo.fetch(branches=["HEAD"])

605

stop_revision = self.target.lookup_foreign_revision_id(refs["HEAD"])

498

refs = interrepo.fetch_refs(branches=["HEAD"])

499

stop_revision = self.target.mapping.revision_id_foreign_to_bzr(refs["HEAD"])

606

500

else:

607

refs = interrepo.fetch(revision_id=stop_revision)

501

refs = interrepo.fetch_refs(revision_id=stop_revision)

608

502

return refs, stop_revision

609

503

610

def pull(self, stop_revision=None, overwrite=False,

611

possible_transports=None, run_hooks=True,local=False):

504

def pull(self, stop_revision=None, overwrite=False,

505

possible_transports=None, local=False):

612

506

# This type of branch can't be bound.

613

507

if local:

614

508

raise errors.LocalRequiresBoundBranch()

622

516

result.new_revid = self.target.last_revision()

623

517

return result

624

518

625

626

class InterToGitBranch(branch.GenericInterBranch):

519

520

class InterToGitBranch(branch.InterBranch):

627

521

"""InterBranch implementation that pulls from Git into bzr."""

628

522

629

def __init__(self, source, target):

630

super(InterToGitBranch, self).__init__(source, target)

631

self.interrepo = repository.InterRepository.get(source.repository,

632

target.repository)

633

634

@staticmethod

635

def _get_branch_formats_to_test():

636

return []

637

638

523

@classmethod

639

524

def is_compatible(self, source, target):

640

return (not isinstance(source, GitBranch) and

525

return (not isinstance(source, GitBranch) and

641

526

isinstance(target, GitBranch))

642

527

643

528

def update_revisions(self, *args, **kwargs):

644

529

raise NoPushSupport()

645

530

646

def _get_new_refs(self, stop_revision=None):

531

def push(self, overwrite=True, stop_revision=None,

532

_override_hook_source_branch=None):

533

raise NoPushSupport()

534

535

def lossy_push(self, stop_revision=None):

536

result = GitBranchPushResult()

537

result.source_branch = self.source

538

result.target_branch = self.target

539

result.old_revid = self.target.last_revision()

647

540

if stop_revision is None:

648

541

stop_revision = self.source.last_revision()

649

assert type(stop_revision) is str

650

main_ref = self.target.ref or "refs/heads/master"

651

refs = { main_ref: (None, stop_revision) }

542

# FIXME: Check for diverged branches

543

refs = { "refs/heads/master": stop_revision }

652

544

for name, revid in self.source.tags.get_tag_dict().iteritems():

653

545

if self.source.repository.has_revision(revid):

654

refs[tag_name_to_ref(name)] = (None, revid)

655

return refs, main_ref

656

657

def pull(self, overwrite=False, stop_revision=None, local=False,

658

possible_transports=None):

659

from dulwich.protocol import ZERO_SHA

660

result = GitBranchPullResult()

661

result.source_branch = self.source

662

result.target_branch = self.target

663

new_refs, main_ref = self._get_new_refs(stop_revision)

664

def update_refs(old_refs):

665

refs = dict(old_refs)

666

# FIXME: Check for diverged branches

667

refs.update(new_refs)

668

return refs

669

old_refs, new_refs = self.interrepo.fetch_refs(update_refs)

670

result.old_revid = self.target.lookup_foreign_revision_id(

671

old_refs.get(main_ref, ZERO_SHA))

672

result.new_revid = new_refs[main_ref]

673

return result

674

675

def push(self, overwrite=False, stop_revision=None,

676

_override_hook_source_branch=None):

677

from dulwich.protocol import ZERO_SHA

678

result = GitBranchPushResult()

679

result.source_branch = self.source

680

result.target_branch = self.target

681

new_refs, main_ref = self._get_new_refs(stop_revision)

682

def update_refs(old_refs):

683

refs = dict(old_refs)

684

# FIXME: Check for diverged branches

685

refs.update(new_refs)

686

return refs

687

old_refs, new_refs = self.interrepo.fetch_refs(update_refs)

688

result.old_revid = self.target.lookup_foreign_revision_id(

689

old_refs.get(main_ref, ZERO_SHA))

690

result.new_revid = new_refs[main_ref]

691

return result

692

693

def lossy_push(self, stop_revision=None):

694

result = GitBranchPushResult()

695

result.source_branch = self.source

696

result.target_branch = self.target

697

new_refs, main_ref = self._get_new_refs(stop_revision)

698

def update_refs(old_refs):

699

refs = dict(old_refs)

700

# FIXME: Check for diverged branches

701

refs.update(new_refs)

702

return refs

703

result.revidmap, old_refs, new_refs = self.interrepo.dfetch_refs(

704

update_refs)

705

result.old_revid = old_refs.get(self.target.ref, (None, NULL_REVISION))[1]

706

result.new_revid = new_refs[main_ref][1]

546

refs["refs/tags/%s" % name] = revid

547

revidmap, new_refs = self.target.repository.dfetch_refs(

548

self.source.repository, refs)

549

if revidmap != {}:

550

self.target.generate_revision_history(revidmap[stop_revision])

551

result.new_revid = revidmap[stop_revision]

552

else:

553

result.new_revid = result.old_revid

554

result.revidmap = revidmap

707

555

return result

708

556

709

557