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