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