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