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