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