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