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