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