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