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