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