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