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