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