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