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