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