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