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