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