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