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