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