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