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