1// Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT. 2 3package medialive 4 5import ( 6 "time" 7 8 "github.com/aws/aws-sdk-go/aws" 9 "github.com/aws/aws-sdk-go/aws/request" 10) 11 12// WaitUntilChannelCreated uses the MediaLive API operation 13// DescribeChannel to wait for a condition to be met before returning. 14// If the condition is not met within the max attempt window, an error will 15// be returned. 16func (c *MediaLive) WaitUntilChannelCreated(input *DescribeChannelInput) error { 17 return c.WaitUntilChannelCreatedWithContext(aws.BackgroundContext(), input) 18} 19 20// WaitUntilChannelCreatedWithContext is an extended version of WaitUntilChannelCreated. 21// With the support for passing in a context and options to configure the 22// Waiter and the underlying request options. 23// 24// The context must be non-nil and will be used for request cancellation. If 25// the context is nil a panic will occur. In the future the SDK may create 26// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 27// for more information on using Contexts. 28func (c *MediaLive) WaitUntilChannelCreatedWithContext(ctx aws.Context, input *DescribeChannelInput, opts ...request.WaiterOption) error { 29 w := request.Waiter{ 30 Name: "WaitUntilChannelCreated", 31 MaxAttempts: 5, 32 Delay: request.ConstantWaiterDelay(3 * time.Second), 33 Acceptors: []request.WaiterAcceptor{ 34 { 35 State: request.SuccessWaiterState, 36 Matcher: request.PathWaiterMatch, Argument: "State", 37 Expected: "IDLE", 38 }, 39 { 40 State: request.RetryWaiterState, 41 Matcher: request.PathWaiterMatch, Argument: "State", 42 Expected: "CREATING", 43 }, 44 { 45 State: request.RetryWaiterState, 46 Matcher: request.StatusWaiterMatch, 47 Expected: 500, 48 }, 49 { 50 State: request.FailureWaiterState, 51 Matcher: request.PathWaiterMatch, Argument: "State", 52 Expected: "CREATE_FAILED", 53 }, 54 }, 55 Logger: c.Config.Logger, 56 NewRequest: func(opts []request.Option) (*request.Request, error) { 57 var inCpy *DescribeChannelInput 58 if input != nil { 59 tmp := *input 60 inCpy = &tmp 61 } 62 req, _ := c.DescribeChannelRequest(inCpy) 63 req.SetContext(ctx) 64 req.ApplyOptions(opts...) 65 return req, nil 66 }, 67 } 68 w.ApplyOptions(opts...) 69 70 return w.WaitWithContext(ctx) 71} 72 73// WaitUntilChannelDeleted uses the MediaLive API operation 74// DescribeChannel to wait for a condition to be met before returning. 75// If the condition is not met within the max attempt window, an error will 76// be returned. 77func (c *MediaLive) WaitUntilChannelDeleted(input *DescribeChannelInput) error { 78 return c.WaitUntilChannelDeletedWithContext(aws.BackgroundContext(), input) 79} 80 81// WaitUntilChannelDeletedWithContext is an extended version of WaitUntilChannelDeleted. 82// With the support for passing in a context and options to configure the 83// Waiter and the underlying request options. 84// 85// The context must be non-nil and will be used for request cancellation. If 86// the context is nil a panic will occur. In the future the SDK may create 87// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 88// for more information on using Contexts. 89func (c *MediaLive) WaitUntilChannelDeletedWithContext(ctx aws.Context, input *DescribeChannelInput, opts ...request.WaiterOption) error { 90 w := request.Waiter{ 91 Name: "WaitUntilChannelDeleted", 92 MaxAttempts: 84, 93 Delay: request.ConstantWaiterDelay(5 * time.Second), 94 Acceptors: []request.WaiterAcceptor{ 95 { 96 State: request.SuccessWaiterState, 97 Matcher: request.PathWaiterMatch, Argument: "State", 98 Expected: "DELETED", 99 }, 100 { 101 State: request.RetryWaiterState, 102 Matcher: request.PathWaiterMatch, Argument: "State", 103 Expected: "DELETING", 104 }, 105 { 106 State: request.RetryWaiterState, 107 Matcher: request.StatusWaiterMatch, 108 Expected: 500, 109 }, 110 }, 111 Logger: c.Config.Logger, 112 NewRequest: func(opts []request.Option) (*request.Request, error) { 113 var inCpy *DescribeChannelInput 114 if input != nil { 115 tmp := *input 116 inCpy = &tmp 117 } 118 req, _ := c.DescribeChannelRequest(inCpy) 119 req.SetContext(ctx) 120 req.ApplyOptions(opts...) 121 return req, nil 122 }, 123 } 124 w.ApplyOptions(opts...) 125 126 return w.WaitWithContext(ctx) 127} 128 129// WaitUntilChannelRunning uses the MediaLive API operation 130// DescribeChannel to wait for a condition to be met before returning. 131// If the condition is not met within the max attempt window, an error will 132// be returned. 133func (c *MediaLive) WaitUntilChannelRunning(input *DescribeChannelInput) error { 134 return c.WaitUntilChannelRunningWithContext(aws.BackgroundContext(), input) 135} 136 137// WaitUntilChannelRunningWithContext is an extended version of WaitUntilChannelRunning. 138// With the support for passing in a context and options to configure the 139// Waiter and the underlying request options. 140// 141// The context must be non-nil and will be used for request cancellation. If 142// the context is nil a panic will occur. In the future the SDK may create 143// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 144// for more information on using Contexts. 145func (c *MediaLive) WaitUntilChannelRunningWithContext(ctx aws.Context, input *DescribeChannelInput, opts ...request.WaiterOption) error { 146 w := request.Waiter{ 147 Name: "WaitUntilChannelRunning", 148 MaxAttempts: 120, 149 Delay: request.ConstantWaiterDelay(5 * time.Second), 150 Acceptors: []request.WaiterAcceptor{ 151 { 152 State: request.SuccessWaiterState, 153 Matcher: request.PathWaiterMatch, Argument: "State", 154 Expected: "RUNNING", 155 }, 156 { 157 State: request.RetryWaiterState, 158 Matcher: request.PathWaiterMatch, Argument: "State", 159 Expected: "STARTING", 160 }, 161 { 162 State: request.RetryWaiterState, 163 Matcher: request.StatusWaiterMatch, 164 Expected: 500, 165 }, 166 }, 167 Logger: c.Config.Logger, 168 NewRequest: func(opts []request.Option) (*request.Request, error) { 169 var inCpy *DescribeChannelInput 170 if input != nil { 171 tmp := *input 172 inCpy = &tmp 173 } 174 req, _ := c.DescribeChannelRequest(inCpy) 175 req.SetContext(ctx) 176 req.ApplyOptions(opts...) 177 return req, nil 178 }, 179 } 180 w.ApplyOptions(opts...) 181 182 return w.WaitWithContext(ctx) 183} 184 185// WaitUntilChannelStopped uses the MediaLive API operation 186// DescribeChannel to wait for a condition to be met before returning. 187// If the condition is not met within the max attempt window, an error will 188// be returned. 189func (c *MediaLive) WaitUntilChannelStopped(input *DescribeChannelInput) error { 190 return c.WaitUntilChannelStoppedWithContext(aws.BackgroundContext(), input) 191} 192 193// WaitUntilChannelStoppedWithContext is an extended version of WaitUntilChannelStopped. 194// With the support for passing in a context and options to configure the 195// Waiter and the underlying request options. 196// 197// The context must be non-nil and will be used for request cancellation. If 198// the context is nil a panic will occur. In the future the SDK may create 199// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 200// for more information on using Contexts. 201func (c *MediaLive) WaitUntilChannelStoppedWithContext(ctx aws.Context, input *DescribeChannelInput, opts ...request.WaiterOption) error { 202 w := request.Waiter{ 203 Name: "WaitUntilChannelStopped", 204 MaxAttempts: 60, 205 Delay: request.ConstantWaiterDelay(5 * time.Second), 206 Acceptors: []request.WaiterAcceptor{ 207 { 208 State: request.SuccessWaiterState, 209 Matcher: request.PathWaiterMatch, Argument: "State", 210 Expected: "IDLE", 211 }, 212 { 213 State: request.RetryWaiterState, 214 Matcher: request.PathWaiterMatch, Argument: "State", 215 Expected: "STOPPING", 216 }, 217 { 218 State: request.RetryWaiterState, 219 Matcher: request.StatusWaiterMatch, 220 Expected: 500, 221 }, 222 }, 223 Logger: c.Config.Logger, 224 NewRequest: func(opts []request.Option) (*request.Request, error) { 225 var inCpy *DescribeChannelInput 226 if input != nil { 227 tmp := *input 228 inCpy = &tmp 229 } 230 req, _ := c.DescribeChannelRequest(inCpy) 231 req.SetContext(ctx) 232 req.ApplyOptions(opts...) 233 return req, nil 234 }, 235 } 236 w.ApplyOptions(opts...) 237 238 return w.WaitWithContext(ctx) 239} 240 241// WaitUntilInputAttached uses the MediaLive API operation 242// DescribeInput to wait for a condition to be met before returning. 243// If the condition is not met within the max attempt window, an error will 244// be returned. 245func (c *MediaLive) WaitUntilInputAttached(input *DescribeInputInput) error { 246 return c.WaitUntilInputAttachedWithContext(aws.BackgroundContext(), input) 247} 248 249// WaitUntilInputAttachedWithContext is an extended version of WaitUntilInputAttached. 250// With the support for passing in a context and options to configure the 251// Waiter and the underlying request options. 252// 253// The context must be non-nil and will be used for request cancellation. If 254// the context is nil a panic will occur. In the future the SDK may create 255// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 256// for more information on using Contexts. 257func (c *MediaLive) WaitUntilInputAttachedWithContext(ctx aws.Context, input *DescribeInputInput, opts ...request.WaiterOption) error { 258 w := request.Waiter{ 259 Name: "WaitUntilInputAttached", 260 MaxAttempts: 20, 261 Delay: request.ConstantWaiterDelay(5 * time.Second), 262 Acceptors: []request.WaiterAcceptor{ 263 { 264 State: request.SuccessWaiterState, 265 Matcher: request.PathWaiterMatch, Argument: "State", 266 Expected: "ATTACHED", 267 }, 268 { 269 State: request.RetryWaiterState, 270 Matcher: request.PathWaiterMatch, Argument: "State", 271 Expected: "DETACHED", 272 }, 273 { 274 State: request.RetryWaiterState, 275 Matcher: request.StatusWaiterMatch, 276 Expected: 500, 277 }, 278 }, 279 Logger: c.Config.Logger, 280 NewRequest: func(opts []request.Option) (*request.Request, error) { 281 var inCpy *DescribeInputInput 282 if input != nil { 283 tmp := *input 284 inCpy = &tmp 285 } 286 req, _ := c.DescribeInputRequest(inCpy) 287 req.SetContext(ctx) 288 req.ApplyOptions(opts...) 289 return req, nil 290 }, 291 } 292 w.ApplyOptions(opts...) 293 294 return w.WaitWithContext(ctx) 295} 296 297// WaitUntilInputDeleted uses the MediaLive API operation 298// DescribeInput to wait for a condition to be met before returning. 299// If the condition is not met within the max attempt window, an error will 300// be returned. 301func (c *MediaLive) WaitUntilInputDeleted(input *DescribeInputInput) error { 302 return c.WaitUntilInputDeletedWithContext(aws.BackgroundContext(), input) 303} 304 305// WaitUntilInputDeletedWithContext is an extended version of WaitUntilInputDeleted. 306// With the support for passing in a context and options to configure the 307// Waiter and the underlying request options. 308// 309// The context must be non-nil and will be used for request cancellation. If 310// the context is nil a panic will occur. In the future the SDK may create 311// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 312// for more information on using Contexts. 313func (c *MediaLive) WaitUntilInputDeletedWithContext(ctx aws.Context, input *DescribeInputInput, opts ...request.WaiterOption) error { 314 w := request.Waiter{ 315 Name: "WaitUntilInputDeleted", 316 MaxAttempts: 20, 317 Delay: request.ConstantWaiterDelay(5 * time.Second), 318 Acceptors: []request.WaiterAcceptor{ 319 { 320 State: request.SuccessWaiterState, 321 Matcher: request.PathWaiterMatch, Argument: "State", 322 Expected: "DELETED", 323 }, 324 { 325 State: request.RetryWaiterState, 326 Matcher: request.PathWaiterMatch, Argument: "State", 327 Expected: "DELETING", 328 }, 329 { 330 State: request.RetryWaiterState, 331 Matcher: request.StatusWaiterMatch, 332 Expected: 500, 333 }, 334 }, 335 Logger: c.Config.Logger, 336 NewRequest: func(opts []request.Option) (*request.Request, error) { 337 var inCpy *DescribeInputInput 338 if input != nil { 339 tmp := *input 340 inCpy = &tmp 341 } 342 req, _ := c.DescribeInputRequest(inCpy) 343 req.SetContext(ctx) 344 req.ApplyOptions(opts...) 345 return req, nil 346 }, 347 } 348 w.ApplyOptions(opts...) 349 350 return w.WaitWithContext(ctx) 351} 352 353// WaitUntilInputDetached uses the MediaLive API operation 354// DescribeInput to wait for a condition to be met before returning. 355// If the condition is not met within the max attempt window, an error will 356// be returned. 357func (c *MediaLive) WaitUntilInputDetached(input *DescribeInputInput) error { 358 return c.WaitUntilInputDetachedWithContext(aws.BackgroundContext(), input) 359} 360 361// WaitUntilInputDetachedWithContext is an extended version of WaitUntilInputDetached. 362// With the support for passing in a context and options to configure the 363// Waiter and the underlying request options. 364// 365// The context must be non-nil and will be used for request cancellation. If 366// the context is nil a panic will occur. In the future the SDK may create 367// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 368// for more information on using Contexts. 369func (c *MediaLive) WaitUntilInputDetachedWithContext(ctx aws.Context, input *DescribeInputInput, opts ...request.WaiterOption) error { 370 w := request.Waiter{ 371 Name: "WaitUntilInputDetached", 372 MaxAttempts: 84, 373 Delay: request.ConstantWaiterDelay(5 * time.Second), 374 Acceptors: []request.WaiterAcceptor{ 375 { 376 State: request.SuccessWaiterState, 377 Matcher: request.PathWaiterMatch, Argument: "State", 378 Expected: "DETACHED", 379 }, 380 { 381 State: request.RetryWaiterState, 382 Matcher: request.PathWaiterMatch, Argument: "State", 383 Expected: "CREATING", 384 }, 385 { 386 State: request.RetryWaiterState, 387 Matcher: request.PathWaiterMatch, Argument: "State", 388 Expected: "ATTACHED", 389 }, 390 { 391 State: request.RetryWaiterState, 392 Matcher: request.StatusWaiterMatch, 393 Expected: 500, 394 }, 395 }, 396 Logger: c.Config.Logger, 397 NewRequest: func(opts []request.Option) (*request.Request, error) { 398 var inCpy *DescribeInputInput 399 if input != nil { 400 tmp := *input 401 inCpy = &tmp 402 } 403 req, _ := c.DescribeInputRequest(inCpy) 404 req.SetContext(ctx) 405 req.ApplyOptions(opts...) 406 return req, nil 407 }, 408 } 409 w.ApplyOptions(opts...) 410 411 return w.WaitWithContext(ctx) 412} 413 414// WaitUntilMultiplexCreated uses the MediaLive API operation 415// DescribeMultiplex to wait for a condition to be met before returning. 416// If the condition is not met within the max attempt window, an error will 417// be returned. 418func (c *MediaLive) WaitUntilMultiplexCreated(input *DescribeMultiplexInput) error { 419 return c.WaitUntilMultiplexCreatedWithContext(aws.BackgroundContext(), input) 420} 421 422// WaitUntilMultiplexCreatedWithContext is an extended version of WaitUntilMultiplexCreated. 423// With the support for passing in a context and options to configure the 424// Waiter and the underlying request options. 425// 426// The context must be non-nil and will be used for request cancellation. If 427// the context is nil a panic will occur. In the future the SDK may create 428// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 429// for more information on using Contexts. 430func (c *MediaLive) WaitUntilMultiplexCreatedWithContext(ctx aws.Context, input *DescribeMultiplexInput, opts ...request.WaiterOption) error { 431 w := request.Waiter{ 432 Name: "WaitUntilMultiplexCreated", 433 MaxAttempts: 5, 434 Delay: request.ConstantWaiterDelay(3 * time.Second), 435 Acceptors: []request.WaiterAcceptor{ 436 { 437 State: request.SuccessWaiterState, 438 Matcher: request.PathWaiterMatch, Argument: "State", 439 Expected: "IDLE", 440 }, 441 { 442 State: request.RetryWaiterState, 443 Matcher: request.PathWaiterMatch, Argument: "State", 444 Expected: "CREATING", 445 }, 446 { 447 State: request.RetryWaiterState, 448 Matcher: request.StatusWaiterMatch, 449 Expected: 500, 450 }, 451 { 452 State: request.FailureWaiterState, 453 Matcher: request.PathWaiterMatch, Argument: "State", 454 Expected: "CREATE_FAILED", 455 }, 456 }, 457 Logger: c.Config.Logger, 458 NewRequest: func(opts []request.Option) (*request.Request, error) { 459 var inCpy *DescribeMultiplexInput 460 if input != nil { 461 tmp := *input 462 inCpy = &tmp 463 } 464 req, _ := c.DescribeMultiplexRequest(inCpy) 465 req.SetContext(ctx) 466 req.ApplyOptions(opts...) 467 return req, nil 468 }, 469 } 470 w.ApplyOptions(opts...) 471 472 return w.WaitWithContext(ctx) 473} 474 475// WaitUntilMultiplexDeleted uses the MediaLive API operation 476// DescribeMultiplex to wait for a condition to be met before returning. 477// If the condition is not met within the max attempt window, an error will 478// be returned. 479func (c *MediaLive) WaitUntilMultiplexDeleted(input *DescribeMultiplexInput) error { 480 return c.WaitUntilMultiplexDeletedWithContext(aws.BackgroundContext(), input) 481} 482 483// WaitUntilMultiplexDeletedWithContext is an extended version of WaitUntilMultiplexDeleted. 484// With the support for passing in a context and options to configure the 485// Waiter and the underlying request options. 486// 487// The context must be non-nil and will be used for request cancellation. If 488// the context is nil a panic will occur. In the future the SDK may create 489// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 490// for more information on using Contexts. 491func (c *MediaLive) WaitUntilMultiplexDeletedWithContext(ctx aws.Context, input *DescribeMultiplexInput, opts ...request.WaiterOption) error { 492 w := request.Waiter{ 493 Name: "WaitUntilMultiplexDeleted", 494 MaxAttempts: 20, 495 Delay: request.ConstantWaiterDelay(5 * time.Second), 496 Acceptors: []request.WaiterAcceptor{ 497 { 498 State: request.SuccessWaiterState, 499 Matcher: request.PathWaiterMatch, Argument: "State", 500 Expected: "DELETED", 501 }, 502 { 503 State: request.RetryWaiterState, 504 Matcher: request.PathWaiterMatch, Argument: "State", 505 Expected: "DELETING", 506 }, 507 { 508 State: request.RetryWaiterState, 509 Matcher: request.StatusWaiterMatch, 510 Expected: 500, 511 }, 512 }, 513 Logger: c.Config.Logger, 514 NewRequest: func(opts []request.Option) (*request.Request, error) { 515 var inCpy *DescribeMultiplexInput 516 if input != nil { 517 tmp := *input 518 inCpy = &tmp 519 } 520 req, _ := c.DescribeMultiplexRequest(inCpy) 521 req.SetContext(ctx) 522 req.ApplyOptions(opts...) 523 return req, nil 524 }, 525 } 526 w.ApplyOptions(opts...) 527 528 return w.WaitWithContext(ctx) 529} 530 531// WaitUntilMultiplexRunning uses the MediaLive API operation 532// DescribeMultiplex to wait for a condition to be met before returning. 533// If the condition is not met within the max attempt window, an error will 534// be returned. 535func (c *MediaLive) WaitUntilMultiplexRunning(input *DescribeMultiplexInput) error { 536 return c.WaitUntilMultiplexRunningWithContext(aws.BackgroundContext(), input) 537} 538 539// WaitUntilMultiplexRunningWithContext is an extended version of WaitUntilMultiplexRunning. 540// With the support for passing in a context and options to configure the 541// Waiter and the underlying request options. 542// 543// The context must be non-nil and will be used for request cancellation. If 544// the context is nil a panic will occur. In the future the SDK may create 545// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 546// for more information on using Contexts. 547func (c *MediaLive) WaitUntilMultiplexRunningWithContext(ctx aws.Context, input *DescribeMultiplexInput, opts ...request.WaiterOption) error { 548 w := request.Waiter{ 549 Name: "WaitUntilMultiplexRunning", 550 MaxAttempts: 120, 551 Delay: request.ConstantWaiterDelay(5 * time.Second), 552 Acceptors: []request.WaiterAcceptor{ 553 { 554 State: request.SuccessWaiterState, 555 Matcher: request.PathWaiterMatch, Argument: "State", 556 Expected: "RUNNING", 557 }, 558 { 559 State: request.RetryWaiterState, 560 Matcher: request.PathWaiterMatch, Argument: "State", 561 Expected: "STARTING", 562 }, 563 { 564 State: request.RetryWaiterState, 565 Matcher: request.StatusWaiterMatch, 566 Expected: 500, 567 }, 568 }, 569 Logger: c.Config.Logger, 570 NewRequest: func(opts []request.Option) (*request.Request, error) { 571 var inCpy *DescribeMultiplexInput 572 if input != nil { 573 tmp := *input 574 inCpy = &tmp 575 } 576 req, _ := c.DescribeMultiplexRequest(inCpy) 577 req.SetContext(ctx) 578 req.ApplyOptions(opts...) 579 return req, nil 580 }, 581 } 582 w.ApplyOptions(opts...) 583 584 return w.WaitWithContext(ctx) 585} 586 587// WaitUntilMultiplexStopped uses the MediaLive API operation 588// DescribeMultiplex to wait for a condition to be met before returning. 589// If the condition is not met within the max attempt window, an error will 590// be returned. 591func (c *MediaLive) WaitUntilMultiplexStopped(input *DescribeMultiplexInput) error { 592 return c.WaitUntilMultiplexStoppedWithContext(aws.BackgroundContext(), input) 593} 594 595// WaitUntilMultiplexStoppedWithContext is an extended version of WaitUntilMultiplexStopped. 596// With the support for passing in a context and options to configure the 597// Waiter and the underlying request options. 598// 599// The context must be non-nil and will be used for request cancellation. If 600// the context is nil a panic will occur. In the future the SDK may create 601// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 602// for more information on using Contexts. 603func (c *MediaLive) WaitUntilMultiplexStoppedWithContext(ctx aws.Context, input *DescribeMultiplexInput, opts ...request.WaiterOption) error { 604 w := request.Waiter{ 605 Name: "WaitUntilMultiplexStopped", 606 MaxAttempts: 28, 607 Delay: request.ConstantWaiterDelay(5 * time.Second), 608 Acceptors: []request.WaiterAcceptor{ 609 { 610 State: request.SuccessWaiterState, 611 Matcher: request.PathWaiterMatch, Argument: "State", 612 Expected: "IDLE", 613 }, 614 { 615 State: request.RetryWaiterState, 616 Matcher: request.PathWaiterMatch, Argument: "State", 617 Expected: "STOPPING", 618 }, 619 { 620 State: request.RetryWaiterState, 621 Matcher: request.StatusWaiterMatch, 622 Expected: 500, 623 }, 624 }, 625 Logger: c.Config.Logger, 626 NewRequest: func(opts []request.Option) (*request.Request, error) { 627 var inCpy *DescribeMultiplexInput 628 if input != nil { 629 tmp := *input 630 inCpy = &tmp 631 } 632 req, _ := c.DescribeMultiplexRequest(inCpy) 633 req.SetContext(ctx) 634 req.ApplyOptions(opts...) 635 return req, nil 636 }, 637 } 638 w.ApplyOptions(opts...) 639 640 return w.WaitWithContext(ctx) 641} 642