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