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