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