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