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